Populating Next Right Pointers in Each Node

Author: idf

src/PopulatingNextRightPointersinEachNode/Solution.java

@@ -0,0 +1,73 @@
+package PopulatingNextRightPointersinEachNode;
+
+import commons.datastructures.TreeLinkNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 21:49
+ *
+ * Given a binary tree
+
+ Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be
+ set to NULL.
+
+ Initially, all next pointers are set to NULL.
+
+ Note:
+
+ You may only use constant extra space.
+ You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two
+ children).
+ For example,
+ Given the following perfect binary tree,
+     1
+   /  \
+  2    3
+ / \  / \
+ 4  5  6  7
+ After calling your function, the tree should look like:
+     1 -> NULL
+   /  \
+  2 -> 3 -> NULL
+ / \  / \
+ 4->5->6->7 -> NULL
+ */
+public class Solution {
+    /**
+     * bfs is trivial
+     * but require constant space thus can only dfs
+     *
+     *
+     * Algorithm:
+     * Since full binary tree, it relies on parent's next
+     *
+     * Notice:
+     * 1. pre-order recursive traversal can be converted to iterative
+     * 2. keep as few iterators as possible
+     * @param root
+     */
+    public void connect_recur(TreeLinkNode root) {
+        if(root==null)
+            return;
+        if(root.left!=null)
+            root.left.next = root.right;
+        if(root.right!=null && root.next!=null)
+            root.right.next = root.next.left;
+        connect_recur(root.left);
+        connect_recur(root.right);
+    }
+
+    public void connect(TreeLinkNode root) {
+        if(root==null)
+            return ;
+        for(TreeLinkNode p=root; p!=null; p=p.left ) {  // vertical
+            for(TreeLinkNode cur=p; cur!=null; cur=cur.next) {  // horizontal
+                if(cur.left!=null)
+                    cur.left.next = cur.right;
+                if(cur.right!=null && cur.next!=null)
+                    cur.right.next = cur.next.left;
+            }
+        }
+    }
+}

src/PopulatingNextRightPointersinEachNodeII/Solution.java

@@ -0,0 +1,96 @@
+package PopulatingNextRightPointersinEachNodeII;
+
+import commons.datastructures.TreeLinkNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 22:51
+ * Follow up for problem "Populating Next Right Pointers in Each Node".
+
+ What if the given tree could be any binary tree? Would your previous solution still work?
+
+ Note:
+
+ You may only use constant extra space.
+ For example,
+ Given the following binary tree,
+    1
+  /  \
+ 2    3
+ / \    \
+ 4   5    7
+ After calling your function, the tree should look like:
+     1 -> NULL
+   /  \
+  2 -> 3 -> NULL
+ / \    \
+4-> 5 -> 7 -> NULL
+ */
+public class Solution {
+    /**
+     * more handling than Populating Next Right Pointers in Each Node
+     *
+     * Notice:
+     * 1. must go to right sub-tree first; consider the example - bottom level only have two nodes: leftmost and rightmost
+     * 2. recursive solution can be converted to iterative solution
+     * 3. Is iterative solution not affected by traversing right subtree first as in recursive solution? Need
+     * modification of the way of going to next level.
+     * @param root
+     */
+    public void connect_recur(TreeLinkNode root) {
+        if(root==null)
+            return;
+        if(root.left!=null) {
+            if(root.right!=null)
+                root.left.next = root.right;
+            else
+                root.left.next = getNextParentNextChild(root);
+        }
+        if(root.right!=null) {
+            root.right.next = getNextParentNextChild(root);
+        }
+
+        connect_recur(root.right);
+        connect_recur(root.left);
+    }
+
+    TreeLinkNode getNextParentNextChild(TreeLinkNode p) {
+        p = p.next;
+        while(p!=null) {
+            if(p.left!=null)
+                return p.left;
+            else if(p.right!=null)
+                return p.right;
+            p = p.next;
+        }
+        return null;
+    }
+
+    public void connect(TreeLinkNode root) {
+        if(root==null)
+            return;
+        for(TreeLinkNode p=root; p!=null; p=nextLevel(p)) {
+            for(TreeLinkNode c=p; c!=null; c=c.next) {
+                if(c.left!=null)
+                    if(c.right!=null)
+                        c.left.next = c.right;
+                    else
+                        c.left.next = getNextParentNextChild(c);
+                if(c.right!=null)
+                    c.right.next = getNextParentNextChild(c);
+            }
+        }
+    }
+
+    TreeLinkNode nextLevel(TreeLinkNode p) {
+        while(p!=null) {
+            if(p.left!=null)
+                return p.left;
+            if(p.right!=null)
+                return p.right;
+            p = p.next;
+        }
+        return null;
+    }
+}

src/commons/datastructures/TreeLinkNode.java

@@ -0,0 +1,12 @@
+package commons.datastructures;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 21:50
+ */
+public class TreeLinkNode {
+    public int val;
+    public TreeLinkNode left, right, next;
+    public TreeLinkNode(int x) { val = x; }
+}