init

Author: hjzheng

1.两数之和.js

@@ -0,0 +1,26 @@
+/*
+ * @lc app=leetcode.cn id=1 lang=javascript
+ *
+ * [1] 两数之和
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+  let map = new Map();
+
+  for (let i = 0; i < nums.length; i++) {
+    if (map.has(nums[i])) {
+      return [map.get(nums[i]), i];
+    } else {
+      map.set(target - nums[i], i);
+    }
+  }
+
+  return [];
+};
+// @lc code=end

102.二叉树的层次遍历.js

@@ -0,0 +1,23 @@
+/*
+ * @lc app=leetcode.cn id=102 lang=javascript
+ *
+ * [102] 二叉树的层次遍历
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function(root) {
+
+};
+// @lc code=end
+

103.二叉树的锯齿形层次遍历.js

@@ -0,0 +1,43 @@
+/*
+ * @lc app=leetcode.cn id=103 lang=javascript
+ *
+ * [103] 二叉树的锯齿形层次遍历
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var zigzagLevelOrder = function(root) {
+  if (!root) return [];
+  let q = [root],
+    res = [];
+
+  while (q.length !== 0) {
+    let size = q.length,
+      currLevel = [];
+
+    for (let i = 0; i < size; i++) {
+      let node = q.shift();
+      (res.length & 1) === 1
+        ? currLevel.unshift(node.val)
+        : currLevel.push(node.val);
+
+      if (node.left) q.push(node.left);
+      if (node.right) q.push(node.right);
+    }
+
+    res.push(currLevel);
+  }
+
+  return res;
+};
+// @lc code=end

107.二叉树的层次遍历-ii.js

@@ -0,0 +1,40 @@
+/*
+ * @lc app=leetcode.cn id=107 lang=javascript
+ *
+ * [107] 二叉树的层次遍历 II
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrderBottom = function(root) {
+  if (!root) return [];
+  let q = [root],
+    res = [];
+
+  while (q.length !== 0) {
+    let size = q.length,
+      currLevel = [];
+
+    for (let i = 0; i < size; i++) {
+      let node = q.shift();
+      currLevel.push(node.val);
+      if (node.left) q.push(node.left);
+      if (node.right) q.push(node.right);
+    }
+
+    res.unshift(currLevel);
+  }
+
+  return res;
+};
+// @lc code=end

112.路径总和.js

@@ -0,0 +1,49 @@
+/*
+ * @lc app=leetcode.cn id=112 lang=javascript
+ *
+ * [112] 路径总和
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, sum) {
+  let res = false,
+    tmp = [],
+    tmpSum = 0;
+
+  function helper(root) {
+    if (!root) return;
+
+    tmp.push(root.val);
+    tmpSum += root.val;
+
+    if (!root.left && !root.right) {
+      if (tmpSum === sum) {
+        res = true;
+        return;
+      }
+    }
+
+    helper(root.left);
+    helper(root.right);
+
+    let val = tmp.pop();
+    tmpSum -= val;
+  }
+
+  helper(root);
+
+  return res;
+};
+// @lc code=end

113.路径总和-ii.js

@@ -0,0 +1,47 @@
+/*
+ * @lc app=leetcode.cn id=113 lang=javascript
+ *
+ * [113] 路径总和 II
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {number[][]}
+ */
+var pathSum = function(root, sum) {
+  let res = [],
+    tmp = [],
+    tmpSum = 0;
+
+  function helper(root) {
+    if (!root) return;
+
+    tmp.push(root.val);
+    tmpSum += root.val;
+
+    if (!root.left && !root.right) {
+      if (tmpSum === sum) {
+        res.push([...tmp]);
+      }
+    }
+
+    helper(root.left);
+    helper(root.right);
+
+    tmpSum -= tmp.pop();
+  }
+
+  helper(root);
+
+  return res;
+};
+// @lc code=end

124.二叉树中的最大路径和.js

@@ -0,0 +1,37 @@
+/*
+ * @lc app=leetcode.cn id=124 lang=javascript
+ *
+ * [124] 二叉树中的最大路径和
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function(root) {
+  let max = Number.MIN_SAFE_INTEGER;
+
+  function helper(root) {
+    if (!root) return 0;
+
+    let left = Math.max(helper(root.left), 0);
+    let right = Math.max(helper(root.right), 0);
+
+    max = Math.max(max, left + right + root.val);
+
+    return root.val + Math.max(left, right);
+  }
+
+  helper(root);
+
+  return max;
+};
+// @lc code=end

153.寻找旋转排序数组中的最小值.js

@@ -0,0 +1,29 @@
+/*
+ * @lc app=leetcode.cn id=153 lang=javascript
+ *
+ * [153] 寻找旋转排序数组中的最小值
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+  let left = 0;
+  let right = nums.length - 1;
+  let mid = 0;
+  while (left < right) {
+    if (nums[left] < nums[right]) {
+      return nums[left];
+    }
+    mid = parseInt((left + right) / 2);
+    if (nums[mid] < nums[right]) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+  return nums[right];
+};
+// @lc code=end

155.最小栈.js

@@ -0,0 +1,61 @@
+/*
+ * @lc app=leetcode.cn id=155 lang=javascript
+ *
+ * [155] 最小栈
+ */
+
+// @lc code=start
+/**
+ * initialize your data structure here.
+ */
+var MinStack = function() {
+  this.stack = [];
+  this._minStack = [];
+};
+
+/**
+ * @param {number} x
+ * @return {void}
+ */
+MinStack.prototype.push = function(x) {
+  let minTop = this._minStack[this._minStack.length - 1];
+  if (minTop === undefined || minTop >= x) {
+    this._minStack.push(x);
+  }
+  this.stack.push(x);
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function() {
+  let top = this.stack.pop();
+  let minTop = this._minStack[this._minStack.length - 1];
+  if (top === minTop) {
+    this._minStack.pop();
+  }
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function() {
+  return this.stack[this.stack.length - 1];
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function() {
+  return this._minStack[this._minStack.length - 1];
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(x)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+// @lc code=end