add more solutions to leetcode

Author: chihungyu1116

1 Two Sum.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    var hash = {};
+    
+    for(var i = 0; i < nums.length; i++){
+        hash[nums[i]] = i;
+    }
+    
+    for(i = 0; i < nums.length; i++){
+        var num = nums[i];
+        var diff = target - num;
+        if(hash[diff] !== undefined && hash[diff] !== i){
+            if(hash[diff] > i){
+                return [i+1, hash[diff]+1];
+            } else {
+                return [hash[diff]+1, i+1]
+            }
+        }
+    }
+    
+    return [];
+};

100 Same Tree.js

@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function(p, q) {
+    var queue1 = [];
+    var queue2 = [];
+    
+    queue1.push(p);
+    queue2.push(q);
+    
+    while(queue1.length && queue2.length){
+        var node1 = queue1.shift();
+        var node2 = queue2.shift();
+        var val1;
+        var val2;
+        
+        
+        if(node1 === null){
+            val1 = null;
+        } else {
+            val1 = node1.val;
+            queue1.push(node1.left);
+            queue1.push(node1.right);
+        }
+        
+        if(node2 === null){
+            val2 = null;
+        } else {
+            val2 = node2.val;
+            queue2.push(node2.left);
+            queue2.push(node2.right);
+        }
+        
+        if(val1 !== val2){
+            return false;
+        }
+    }
+    
+    return queue1.length === queue2.length;
+};

101 Symmetric Tree.js

@@ -0,0 +1,64 @@
+/**
+ * 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) {
+    if(root === null){
+        return true;
+    }
+    
+    var queue = [];
+    queue.push(root);
+    
+    var temp = [];
+    var curCnt = 1;
+    var nextCnt = 0;
+
+    while(queue.length !== 0){
+        var p = queue.shift();
+        
+        if(p !== null){
+            temp.push(p.left);
+            temp.push(p.right);
+        }
+        
+        if(queue.length === 0){
+            if(isPalindrome(temp)){
+                queue = temp;
+                temp = [];
+            } else {
+                return false;
+            }
+        }
+    }
+    
+    return true;
+};
+
+
+var isPalindrome = function(arr){
+    var head = 0;
+    var tail = arr.length - 1;
+    
+    while(head < tail){
+        if(arr[head] && arr[tail]){
+            if(arr[head].val !== arr[tail].val){
+                return false;
+            }
+        } else if(arr[head] || arr[tail]){
+            return false;
+        }
+        
+        head++;
+        tail--;
+    }
+    
+    return true;
+}

102 Binary Tree Level Order Traversal.js

@@ -0,0 +1,49 @@
+/**
+ * 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) {
+    var result = [];
+    
+    if(root === null){
+        return result;
+    }
+    
+    var queue = [];
+    var temp = [];
+    var curLvlCnt = 1;
+    var nextLvlCnt = 0;
+    
+    queue.push(root);
+    
+    while(queue.length !== 0){
+        var p = queue.shift();
+        temp.push(p.val);
+        curLvlCnt--;
+        
+        if(p.left){
+            queue.push(p.left);
+            nextLvlCnt++;
+        }
+        if(p.right){
+            queue.push(p.right);
+            nextLvlCnt++;
+        }
+        
+        if(curLvlCnt === 0){
+            result.push(temp);
+            curLvlCnt = nextLvlCnt;
+            nextLvlCnt = 0;
+            temp = [];
+        }
+    }
+    
+    return result;
+};

104 Maximum Depth of Binary Tree.js

@@ -0,0 +1,18 @@
+/**
+ * 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 === null){
+      return 0;
+  }  
+  
+  return 1+ Math.max(maxDepth(root.left), maxDepth(root.right));
+};

106 Construct Binary Tree from Inorder and Postorder Traversal.js

@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} inorder
+ * @param {number[]} postorder
+ * @return {TreeNode}
+ */
+var buildTree = function(inorder, postorder) {
+    if(inorder === null || postorder === null){
+        return null;
+    }
+    
+    if(inorder.length !== postorder.length){
+        return null;
+    }
+    
+    return generate(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
+};
+
+var generate = function(inorder, il, ir, postorder, pl, pr){
+    if(il > ir || pl > pr){
+        return null;
+    }
+    
+    var rootVal = postorder[pr];
+    var root = new TreeNode(rootVal);
+    var rootIndex = -1;
+    
+    for(var i = il; i <= ir; i++){
+        var nodeVal = inorder[i];
+        if(nodeVal === rootVal){
+            rootIndex = i;
+            break;
+        }
+    }
+    
+    if(rootIndex === -1){
+        return null;
+    }
+    
+    var leftTreeSize = rootIndex - il;
+    var rightTreeSize = ir - rootIndex;
+    
+    root.left = generate(inorder, il, rootIndex - 1, postorder, pl, pl + leftTreeSize - 1);
+    root.right = generate(inorder, rootIndex + 1, ir, postorder, pr - rightTreeSize, pr - 1);
+    
+    return root;
+}

107 Binary Tree Level Order Traversal II.js

@@ -0,0 +1,50 @@
+/**
+ * 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) {
+    var q = [];
+    var result = [];
+    var temp = [];
+    
+    if(root === null){
+        return q;
+    }
+    
+    q.push(root);
+    
+    var curLvlCnt = 1;
+    var nextLvlCnt = 0;
+    
+    while(q.length !== 0){
+        var p = q.shift();
+        curLvlCnt--;
+        temp.push(p.val);
+        
+        if(p.left !== null){
+            q.push(p.left);
+            nextLvlCnt++;
+        }
+        
+        if(p.right !== null){
+            q.push(p.right);
+            nextLvlCnt++;
+        }
+        
+        if(curLvlCnt === 0){
+            curLvlCnt = nextLvlCnt;
+            nextLvlCnt = 0;
+            result.unshift(temp.slice());
+            temp = [];
+        }
+    }
+    
+    return result;
+};

108 Convert Sorted Array to Binary Search Tree.js

@@ -0,0 +1,35 @@
+// Leetcode 108 
+// Language: Javascript
+// Problem: https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
+// Author: Chihung Yu
+/**
+ * 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) {
+    return generate(nums,0,nums.length-1);
+};
+
+var generate = function(nums, start, end){
+    
+    if(start > end){
+        return null;
+    }
+    var midIndex = start + parseInt((end - start)/2);
+    var midVal = nums[midIndex];
+    
+    var left = generate(nums, start, midIndex-1);
+    var node = new TreeNode(midVal);
+    node.left = left;
+    var right = generate(nums, midIndex+1, end);
+    node.right = right;
+    
+    return node;
+}

11 Container With Most Water.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function(height) {
+    var left = 0;
+    var right = height.length - 1;
+    var maxVal = 0;
+    
+    while(left<right){
+        var contain = (right-left)*Math.min(height[left],height[right]);
+        maxVal = Math.max(contain, maxVal);
+        
+        if(height[left] >= height[right]){
+            right--;
+        } else {
+            left++;
+        }
+    }
+    
+    return maxVal;
+};