Merge branch 'master' of https://github.com/jyxia/LeetCode-JavaScript

Author: jyxia

Easy/102-binaryTreeLevelOrder.js

@@ -72,7 +72,7 @@ var levelOrder = function(root) {
 
 var helper = function(results, node, level) {
     if (!node) return results;
-    if (level >= results.length) {
+    if (level === results.length) {
         results[level] = [];
     }
     results[level].push(node.val);

Hard/117-populatingNextRightII.js

@@ -0,0 +1,104 @@
+/**
+ * Definition for binary tree with next pointer.
+ * function TreeLinkNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = this.next = null;
+ * }
+ */
+
+/**
+ * @param {TreeLinkNode} root
+ * @return {void} Do not return anything, modify tree in-place instead.
+ */
+// BFS, level order Traversal, set a dummy head at the beginnig of each level.
+// Is it O(1) space?
+var connect = function(root) {
+    while (root) {
+        var leftDummy = new TreeLinkNode(0);
+        var currChild = leftDummy;
+        while (root) {
+            if (root.left) {
+                currChild.next = root.left;
+                currChild = currChild.next;
+            }
+            if (root.right) {
+                currChild.next = root.right;
+                currChild = currChild.next;
+            }
+            root = root.next;
+        }
+        // reset head to the left of each level.
+        root = leftDummy.next;
+    }
+};
+
+
+/**
+ * Definition for binary tree with next pointer.
+ * function TreeLinkNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = this.next = null;
+ * }
+ */
+
+// BFS too, but constant space
+var connect = function(root) {
+    // next level's head (beginnig)
+    var head = root;
+    // next level's last visited node
+    var prev;
+    // curr level's currently visiting node
+    var curr;
+    while (head) {
+        curr = head;
+        prev = null;
+        head = null;
+        while (curr) {
+            if (curr.left) {
+                if (prev) prev.next = curr.left;
+                else head = curr.left;
+                prev = curr.left;
+            }
+            if (curr.right) {
+                if (prev) prev.next = curr.right;
+                else head = curr.right;
+                prev = curr.right;
+            }
+            curr = curr.next;
+        }
+    }
+};
+
+// doesn't work, wrong answer. e.g. {1,2,3,4,5,#,6,7,#,#,#,#,8},
+// the common parent is one more level up
+var connect = function(root) {
+    if (!root) return;
+
+    while (root) {
+        var pNode = root;
+        while (pNode) {
+            var child = null;
+            if (pNode.left && pNode.right) {
+                pNode.left.next = pNode.right;
+                child = pNode.right;
+            } else {
+                if (pNode.left) child = pNode.left;
+                if (pNode.right) child = pNode.right;
+            }
+            if (child) {
+                if (pNode.next) {
+                    if (pNode.next.left) child.next = pNode.next.left;
+                    else child.next = pNode.next.right;
+                }
+            }
+            pNode = pNode.next;
+        }
+
+        while (root && !root.left && !root.right) {
+            root = root.next;
+        }
+        if (!root) break;
+        if (root.left) root = root.left;
+        else if (root.right) root = root.right;
+    }
+};

Hard/145-binaryTreePostorder.js

@@ -0,0 +1,62 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+// looks like there is a better way to implement
+var postorderTraversal = function(root) {
+    var result = [];
+    if (!root) return result;
+    var stack = [root];
+    var preVisitedNode = null;
+
+    while (stack.length > 0) {
+        node = stack[stack.length - 1];
+        if (!node.left && !node.right ||
+            (preVisitedNode && (preVisitedNode === node.right || preVisitedNode === node.left))) {
+            result.push(node.val);
+            preVisitedNode = stack.pop();
+        } else {
+            if (node.right) {
+                stack.push(node.right);
+            }
+            if (node.left) {
+                stack.push(node.left);
+            }
+        }
+    }
+
+    return result;
+};
+
+// an improved version
+var postorderTraversal = function(root) {
+    var result = [];
+    if (!root) return result;
+    var stack = [root];
+
+    while (stack.length > 0) {
+        var node = stack[stack.length - 1];
+        if (!node.left && !node.right) {
+            result.push(node.val);
+            node = stack.pop();
+        } else {
+            if (node.right) {
+                stack.push(node.right);
+                node.right = null;
+            }
+            if (node.left) {
+                stack.push(node.left);
+                node.left = null;
+            }
+        }
+    }
+
+    return result;
+};

Medium/116-PopulatingNextRightPointersinEachNode.js

@@ -9,7 +9,7 @@
 /**
  * Key: if a node is a parent's left child, then this node's next is its parent's right child node.
  * if a node is a parent node's right child, then this node's next is its parent's next node's left node.
- * (the parent node should have next child). The trick part is how to write code. 
+ * (the parent node should have next child). The trick part is how to write code.
  *
  * @param {TreeLinkNode} root
  * @return {void} Do not return anything, modify tree in-place instead.
@@ -27,3 +27,24 @@ var connect = function(root) {
         root = root.left;
     }
 };
+
+// second try, slow, but easy understanding
+// the space is not constant
+var connect = function(root) {
+    if (!root) return;
+    root.next = null;
+    var queue = [root];
+    while (queue.length > 0) {
+        var node = queue.shift();
+        if (node.left) {
+            node.left.next = node.right;
+            queue.push(node.left);
+        }
+        if (node.right) {
+            if (node.next) {
+                node.right.next = node.next.left;
+            }
+            queue.push(node.right);
+        }
+    }
+};

Medium/139-wordBreak.js

@@ -6,7 +6,7 @@
  * @return {boolean}
  */
 
-// recursion, not accepted, time exceeds limits.
+// recursion, not accepted, time exceeds limits. O(N^2)
 var wordBreak = function(s, wordDict) {
     return helper(s, wordDict, 0);
 };
@@ -22,3 +22,19 @@ var helper = function(s, wordDict, start) {
     }
     return false;
 };
+
+// Dynamic, accepted
+var wordBreak = function(s, wordDict) {
+    var canBreak = [true];
+    for (var i = 0; i < s.length; i++) {
+        if (!canBreak[i]) continue;
+        for (var word of wordDict) {
+            var wLength = word.length;
+            if (canBreak[i + wLength]) continue;
+            if (s.substring(i, i + wLength) === word) {
+                canBreak[i + wLength]  = true;
+            }
+        }
+    }
+    return canBreak[s.length] ? true : false;
+};

Medium/144-binaryTreePreorder.js

@@ -24,3 +24,24 @@ var preorderTraversal = function(root) {
     }
     return order;
 };
+
+// this is a more straightforward method, but slower than first one.
+// stack tracks the node visit order
+var preorderTraversal = function(root) {
+    if (!root) return [];
+    var result = [];
+    var stack = [root];
+
+    while (stack.length > 0) {
+        var node = stack.pop();
+        result.push(node.val);
+        if (node.right) {
+            stack.push(node.right);
+        }
+        if (node.left) {
+            stack.push(node.left);
+        }
+    }
+
+    return result;
+};

Medium/173-binarySearchTreeIterator.js

@@ -0,0 +1,50 @@
+/**
+ * Definition for binary tree
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @constructor
+ * @param {TreeNode} root - root of the binary search tree
+ */
+// Is there a better solution?
+var BSTIterator = function(root) {
+    this.stack = [];
+    this.pushStack(root);
+};
+
+/**
+ * @this BSTIterator
+ * @returns {boolean} - whether we have a next smallest number
+ */
+BSTIterator.prototype.hasNext = function() {
+    return this.stack.length > 0 ? true : false;
+};
+
+/**
+ * @this BSTIterator
+ * @returns {number} - the next smallest number
+ */
+BSTIterator.prototype.next = function() {
+    var small = this.stack.pop();
+    if (small.right) {
+        this.pushStack(small.right);
+    }
+    return small.val;
+};
+
+BSTIterator.prototype.pushStack = function(node) {
+    while (node) {
+        this.stack.push(node);
+        node = node.left;
+    }
+};
+
+/**
+ * Your BSTIterator will be called like this:
+ * var i = new BSTIterator(root), a = [];
+ * while (i.hasNext()) a.push(i.next());
+*/

Medium/179-largestNumber.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {string}
+ */
+var largestNumber = function(nums) {
+    nums.sort(function(a, b) {
+        var ab = a + '' + b;
+        var ba = b + '' + a;
+        if (ab < ba) return 1;
+        else if (ab > ba) return -1;
+        return 0;
+    });
+    if (nums[0] === 0) return '0';
+    return nums.join('');
+};
+
+// this is a wrong solution e.g. [121,12] '12' < '121', then it doesn't work.
+var largestNumber = function(nums) {
+    nums.sort(function(a, b) {
+        if (a.toString() < b.toString()) return 1;
+        else if (a.toString() > b.toString()) return -1;
+        else return 0;
+    });
+    if (nums[0] === 0) return '0';
+    return nums.join('');
+};

Medium/230-kthSmallestElementinBST.js

@@ -29,3 +29,21 @@ var kthSmallest = function(root, k) {
         }
     }
 };
+
+// second try
+var kthSmallest = function(root, k) {
+    var stack = [];
+
+    while (root || stack.length > 0) {
+        while (root) {
+            stack.push(root);
+            root = root.left;
+        }
+        root = stack.pop();
+        k--;
+        if (k === 0) return root.val;
+        root = root.right;
+    }
+
+    return 0;
+};

Medium/60-permutationSequence.js

@@ -0,0 +1,30 @@
+/**
+ * @see inline comments
+ *
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+var getPermutation = function(n, k) {
+    var nums = [];
+    for (var i = 0; i < n; i ++) {
+        nums.push(i + 1);
+    }
+    k--;
+    var mod = 1;
+    for (i = 1; i < n; i++) {
+        mod *= i;
+    }
+    var result = '';
+    for (i = 0; i < n; i++) {
+        // find the index of current number's first digit
+        var index = Math.floor(k / mod);
+        k = k % mod;
+        result += nums[index];
+        // remove this used number from nums.
+        nums.splice(index, 1);
+        mod = Math.floor(mod / (n - i - 1));
+    }
+
+    return result;
+};