Add code for iterative tree

Author: zdong1995

src/main/java/algorithm/basic/iterativetree/FlattenMultiLevelList.java

@@ -0,0 +1,45 @@
+package algorithm.basic.iterativetree;
+
+/**
+ * You are given a doubly linked list which in addition to the next and previous pointers,
+ * it could have a child pointer, which may or may not point to a separate doubly linked list.
+ * These child lists may have one or more children of their own, and so on.
+ *
+ * Flatten the list so that all the nodes appear in a single-level, doubly linked list.
+ * You are given the head of the first level of the list.
+ */
+public class FlattenMultiLevelList {
+    public Node flatten(Node head) {
+        Node cur = head;
+        while (cur != null) {
+            // case 1: no child, no need to flatten child list
+            if (cur.child == null) {
+                cur = cur.next;
+                continue;
+            }
+            // case 2: has child, find tail of child list, connect to next
+            Node tail = cur.child;
+            while (tail.next != null) {
+                tail = tail.next;
+            }
+            // connect with the child list
+            tail.next = cur.next;
+            if (cur.next != null) { // avoid NPE, cur maybe the last node
+                cur.next.prev = tail;
+            }
+            cur.next = cur.child;
+            cur.child.prev = cur;
+            cur.child = null; // delink
+            // traverse next node
+            cur = cur.next;
+        }
+        return head;
+    }
+
+    private static class Node {
+        int val;
+        Node next;
+        Node prev;
+        Node child;
+    }
+}

src/main/java/algorithm/basic/iterativetree/FlattenTreeToList.java

@@ -0,0 +1,32 @@
+package algorithm.basic.iterativetree;
+
+import datastrcture.*;
+
+/**
+ * Given a binary tree, flatten it to a linked list in-place.
+ */
+
+public class FlattenTreeToList {
+    public void flatten(TreeNode root) {
+        if (root == null) { // base case
+            return;
+        }
+        TreeNode cur = root;
+        while (cur != null) { // traverse down along the rightmost path
+            TreeNode next = cur.right; // store next node
+            // flatten the left subtree to insert between cur and cur.right
+            if (cur.left != null) {
+                // find the tail of the right subtree of cur.left
+                TreeNode tail = cur.left;
+                while (tail.right != null) {
+                    tail = tail.right;
+                }
+                // connect the tail to stored next
+                tail.right = next;
+                cur.right = cur.left;
+                cur.left = null; // delink
+            }
+            cur = cur.right;
+        }
+    }
+}

src/main/java/algorithm/basic/iterativetree/PopulateNextRight.java

@@ -0,0 +1,49 @@
+package algorithm.basic.iterativetree;
+
+/**
+ * You are given a perfect binary tree where all leaves are on the same level, and every parent has two children.
+ * The binary tree has the following definition:
+ * class Node {
+ *   int val;
+ *   Node left;
+ *   Node right;
+ *   Node next;
+ * }
+ *
+ *
+ * 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.
+ */
+public class PopulateNextRight {
+    public Node connect(Node root) {
+        if (root == null) {
+            return root;
+        }
+        Node leftMost = root;
+        while (leftMost.left != null) {
+            // start from the leftmost node, connect current level
+            Node cur = leftMost;
+            while (cur != null) { // traverse the linked list of current level
+                // connect for same root nodes
+                cur.left.next = cur.right;
+                // connect for inter-root nodes
+                if (cur.next != null) { // avoid NPE
+                    cur.right.next = cur.next.left;
+                }
+                cur = cur.next;
+            }
+            leftMost = leftMost.left;
+            // traverse the left most path to arrive last level
+        }
+        return root;
+    }
+
+    private static class Node {
+        int val;
+        Node left;
+        Node right;
+        Node next;
+    }
+}

src/main/java/algorithm/basic/iterativetree/PopulateNextRight2.java

@@ -0,0 +1,61 @@
+package algorithm.basic.iterativetree;
+
+/**
+ * You are given a tree:
+ * class Node {
+ *   int val;
+ *   Node left;
+ *   Node right;
+ *   Node next;
+ * }
+ *
+ *
+ * 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.
+ */
+public class PopulateNextRight2 {
+    public Node connect2(Node root) {
+        if (root == null) {
+            return null;
+        }
+        Node leftMost = root;
+        while (leftMost != null) {
+            // start from leftMost node to traverse current level
+            // and connect the next level
+            Node cur = leftMost; // current node at current level
+            Node dummy = new Node(0); // used to store head of next level
+            Node prev = dummy; // the leading node of next level
+            // use dummy to avoid null check to simplify the implementation
+            while (cur != null) {
+                // traverse current level to connect next level node
+                // populate prev.next to next node in the next level
+                if (cur.left != null) {
+                    prev.next = cur.left;
+                    prev = prev.next;
+                }
+                if (cur.right != null) {
+                    prev.next = cur.right;
+                    prev = prev.next;
+                }
+                // move to next node in current level
+                cur = cur.next;
+            }
+            // move leftMost to left most node (head) of next level
+            leftMost = dummy.next;
+        }
+        return root;
+    }
+
+    private static class Node {
+        int val;
+        Node left;
+        Node right;
+        Node next;
+
+        public Node(int val) {
+            this.val = val;
+        }
+    }
+}