add 117 populating next right, add 173 bstIterator, add 179 largestNumber

Author: jyxia

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

@@ -34,3 +34,29 @@ var postorderTraversal = function(root) {
 
     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/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('');
+};

README.md

@@ -143,6 +143,8 @@
 * [152. Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/) - [Solution](./Medium/152-MaxProductSubarray.js)
 * [153.	Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/) - [Solution](./Medium/153-findMinimumInRotatedSortedArray.js)
 * [162. Find Peak Element](https://leetcode.com/problems/find-peak-element/) - [Solution](./Medium/162-findPeakElement.js)
+* [173. Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/) - [Solution](./Medium/173-binarySearchTreeIterator.js)
+* [179. Largest Number](https://leetcode.com/problems/largest-number/) - [Solution](./Medium/179-largestNumber.js)
 * [199. Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/) - [Solution](./Medium/199-binaryTreeRightSideView.js)
 * [213. House Robber II](https://leetcode.com/problems/house-robber-ii/) - [Solution](./Medium/213-houseRobberII.js)
 * [215. Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) - [Solution](./Medium/215-KthLargestElementInArray.js)
@@ -170,6 +172,7 @@
 * [56. Merge Intervals](https://leetcode.com/problems/merge-intervals/) -  [Solution](./Hard/56-MergeIntervals.js)
 * [57. Insert Interval](https://leetcode.com/problems/insert-interval/) -  [Solution](./Hard/57-insertInterval.js)
 * [115. Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/) -  [Solution](./Hard/115-distinctSubsequences.js)
+* [117. Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/) -  [Solution](./Hard/117-populatingNextRightII.js)
 * [123. Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/) -  [Solution](./Hard/123-bestTimeBuySellStockIII.js)
 * [132. Palindrome Partitioning II](https://leetcode.com/problems/palindrome-partitioning-ii/) -  [Solution](./Hard/132-palindromePartitioningII.js)
 * [145. Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) -  [Solution](./Hard/145-binaryTreePostorder.js)