📖 add 200

Author: gankaicode

101.对称二叉树.js

@@ -0,0 +1,31 @@
+/*
+ * @lc app=leetcode.cn id=101 lang=javascript
+ *
+ * [101] 对称二叉树
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function(root) {
+    return helper(root, root)
+};
+
+const helper = function(p, q) {
+    if (p == null && q == null)
+        return true
+    if (p == null || q == null)
+        return false
+    return p.val == q.val && helper(p.left, q.right) && helper(p.right, q.left)
+}
+// @lc code=end
+

104.二叉树的最大深度.js

@@ -0,0 +1,26 @@
+/*
+ * @lc app=leetcode.cn id=104 lang=javascript
+ *
+ * [104] 二叉树的最大深度
+ */
+
+// @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 maxDepth = function(root) {
+    if(root === undefined || root===null){
+        return 0;
+    }
+    return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
+};
+// @lc code=end
+

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

@@ -0,0 +1,63 @@
+/*
+ * @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) {
+    let h = height(root); /* get the height using helper fn below */
+    let results = []; /* init an array to hold final answer */
+    let depth = 1; /* init depth to 1 since we are using 1-based height */
+    for (depth; depth <= h; depth++) {
+      /* iterate from depth to tree height */
+      results.push(levelOrder(root, depth)); /* push an array of each level's node values to results */
+    }
+  
+    return results.reverse();
+  };
+  
+  /*
+    recursive level-order traversal which collects all nodes
+    from each level into an array.
+  */
+  function levelOrder(node, d, level = []) {
+    if (node == null) {
+      return level;
+    }
+    if (d === 1) {
+      level.push(node.val);
+    } else if (d > 1) {
+      levelOrder(node.left, d - 1, level);
+      levelOrder(node.right, d - 1, level);
+    }
+    return level;
+  }
+  
+  /*
+    computes the largest root-to-leaf path,
+    using 1-based counting.
+  */
+  function height(node) {
+    if (node == null) {
+      /* base case */
+      return 0;
+    }
+    let left = height(node.left);
+    let right = height(node.right);
+  
+    return Math.max(left, right) + 1;
+  }
+// @lc code=end
+

108.将有序数组转换为二叉搜索树.js

@@ -0,0 +1,32 @@
+/*
+ * @lc app=leetcode.cn id=108 lang=javascript
+ *
+ * [108] 将有序数组转换为二叉搜索树
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} nums
+ * @return {TreeNode}
+ */
+var sortedArrayToBST = function(nums) {
+    if (!nums.length) return null;
+    
+    const mid = Math.floor(nums.length / 2);
+    const root = new TreeNode(nums[mid]);
+    
+    // subtrees are BSTs as well
+    root.left = sortedArrayToBST(nums.slice(0, mid));
+    root.right = sortedArrayToBST(nums.slice(mid + 1));
+    
+    return root;
+};
+// @lc code=end
+

110.平衡二叉树.js

@@ -0,0 +1,33 @@
+/*
+ * @lc app=leetcode.cn id=110 lang=javascript
+ *
+ * [110] 平衡二叉树
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isBalanced = function(root) {
+    
+    let dfs = function(node) {
+        if (!node) return 0;
+        let left = 1 + dfs(node.left);
+        let right = 1 + dfs(node.right);
+        if (Math.abs(left - right) > 1) return Infinity;
+        return Math.max(left, right);
+    }
+    
+    return dfs(root)==Infinity?false:true;
+};
+// @lc code=end
+

111.二叉树的最小深度.js

@@ -0,0 +1,27 @@
+/*
+ * @lc app=leetcode.cn id=111 lang=javascript
+ *
+ * [111] 二叉树的最小深度
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minDepth = function(root) {
+    if (root === null) return 0;
+    if (root.left === null) return minDepth(root.right) + 1;
+    if (root.right === null) return minDepth(root.left) + 1;
+    return Math.min( minDepth(root.left), minDepth(root.right) ) + 1;
+};
+// @lc code=end
+

112.路径总和.js

@@ -0,0 +1,30 @@
+/*
+ * @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) {
+    if (!root) return false;
+
+    if (!root.left && !root.right) { // check leaf
+        return sum === root.val;
+    } else { // continue DFS
+        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+    }
+};
+// @lc code=end
+

118.杨辉三角.js

@@ -0,0 +1,25 @@
+/*
+ * @lc app=leetcode.cn id=118 lang=javascript
+ *
+ * [118] 杨辉三角
+ */
+
+// @lc code=start
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+var generate = function(numRows) {
+    var pascal = [];
+    for (var i = 0; i < numRows; i++) {
+        pascal[i] = [];
+        pascal[i][0] = 1;
+        for (var j = 1; j < i; j++) {
+            pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j]
+        }
+        pascal[i][i] = 1;
+    }
+    return pascal;
+};
+// @lc code=end
+

119.杨辉三角-ii.js

@@ -0,0 +1,26 @@
+/*
+ * @lc app=leetcode.cn id=119 lang=javascript
+ *
+ * [119] 杨辉三角 II
+ */
+
+// @lc code=start
+/**
+ * @param {number} rowIndex
+ * @return {number[]}
+ */
+var getRow = function(rowIndex) {
+    var row = [1];
+    
+    for(var i = 1 ; i <= rowIndex ; i++) {
+        for(var j = i; j > 0; j--) {
+            if(j === i)
+                row[j] = 1;
+            else
+                row[j] = row[j - 1] + row[j];
+        }
+    }
+    return row;
+};
+// @lc code=end
+

122.买卖股票的最佳时机-ii.js

@@ -0,0 +1,27 @@
+/*
+ * @lc app=leetcode.cn id=122 lang=javascript
+ *
+ * [122] 买卖股票的最佳时机 II
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let profit = 0;
+
+    for (let i = 1; i < prices.length; i++) {
+        let prev = prices[i - 1];
+        let current = prices[i];
+
+        if (prev < current) {
+            profit += current - prev;
+        }
+    }
+    
+    return profit;
+};
+// @lc code=end
+

125.验证回文串.js

@@ -36,10 +36,49 @@
  * @param {string} s
  * @return {boolean}
  */
-var isPalindrome = function (s) {
-    let cop = s.toLocaleLowerCase().replace(/\W/g, '')
-    let rev = cop.split('').reverse().join('')
-    return cop === rev
+var isPalindrome = function (input) {
+    var start = 0
+    var end = input.length - 1
+    while (start < end) {
+        var s = input.charCodeAt(start)
+        var e = input.charCodeAt(end)
+    
+        if (!isLetter(s)) {
+            start++
+            continue
+        }
+        if (!isLetter(e)) {
+            end--
+            continue
+        }
+    
+        if (toLowerCase(s) !== toLowerCase(e)) {
+            return false 
+        } 
+        start++
+        end--
+  }
+  return true
+};
+
+var isLetter = function(code) {
+    if (((code >= 48) && (code <= 57))  // numbers
+    || ((code >= 65) && (code <= 90))  // uppercase
+    || ((code >= 97) && (code <= 122))) {  // lowercase
+        return true
+    }
+    else {
+        return false
+    }
+}
+
+var toLowerCase = function(code) {
+    if (code >= 65 && code <= 90) {
+        return code + 32    
+    }
+    else {
+        return code
+    }
 };
 // @lc code=end