LeetCode: Populating Next Right Pointers in Each Node II 解題報告

Populating Next Right Pointers in Each Node II
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

SOLUTION 1

本題還是可以用Level Traversal 輕松解出，連代碼都可以跟上一個題目一模一樣。Populating Next Right Pointers in Each Node Total

但是不符合空間復雜度的要求：constant extra space. 

時間復雜度： O(N)

/**
 * Definition for binary tree with next pointer.
 * public class TreeLinkNode {
 *     int val;
 *     TreeLinkNode left, right, next;
 *     TreeLinkNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void connect(TreeLinkNode root) {
        if (root == null) {
            return;
        }
        
        TreeLinkNode dummy = new TreeLinkNode(0);
        Queue<TreeLinkNode> q = new LinkedList<TreeLinkNode>();
        
        q.offer(root);
        q.offer(dummy);
        
        while(!q.isEmpty()) {
            TreeLinkNode cur = q.poll();
            if (cur == dummy) {
                if (!q.isEmpty()) {
                    q.offer(dummy);
                }
                continue;
            }
            
            if (q.peek() == dummy) {
                cur.next = null;
            } else {
                cur.next = q.peek();    
            }
            
            if (cur.left != null) {
                q.offer(cur.left);
            }
            
            if (cur.right != null) {
                q.offer(cur.right);
            }
        }
        
    }
}

 

SOLUTION 2

我們可以用遞歸解出。注意從右往左加next。否則的話 右邊未建立，左邊你沒找不到next. Space Complexity:

時間復雜度： O(N)

public void connect(TreeLinkNode root) {
        if (root == null) {
            return;
        }
        
        TreeLinkNode cur = root.next;
        TreeLinkNode next = null;
        // this is very important. should exit after found the next.
        while (cur != null && next == null) {
            if (cur.left != null) {
                next = cur.left;
            } else if (cur.right != null) {
                next = cur.right;
            } else {
                cur = cur.next;
            }
        }
        
        if (root.right != null) {
            root.right.next = next;
            next = root.right;
        }
        
        if (root.left != null) {
            root.left.next = next;
        }
        
        // The order is very important. We should deal with right first!
        connect(root.right);
        connect(root.left);
    }

2014.1229 redo:

但現在leetcode加強數據了，不管怎么優化，遞歸的版本再也不能通過，都TLE

// SOLUTION 2: REC
    public void connect(TreeLinkNode root) {
        if (root == null) {
            return;
        }
        
        TreeLinkNode dummy = new TreeLinkNode(0);
        TreeLinkNode pre = dummy;
        
        if (root.left != null) {
            pre.next = root.left;
            pre = root.left;
        }
        
        if (root.right != null) {
            pre.right = root.right;
            pre = root.right;
        }
        
        if (root.left == null && root.right == null) {
            return;
        }
        
        // Try to find the next node;
        TreeLinkNode cur = root.next;
        TreeLinkNode next = null;
        while (cur != null) {
            if (cur.left != null) {
                next = cur.left;
                break;
            } else if (cur.right != null) {
                next = cur.right;
                break;
            } else {
                cur = cur.next;
            }
        }
        
        pre.next = next;
        
        if (root.right != null && (root.right.left != null || root.right.right != null)) {
            connect(root.right);    
        }
        
        if (root.left != null && (root.left.left != null || root.left.right != null)) {
            connect(root.left);    
        }
        
    }

 

SOLUTION 3

我們可以用Iterator 直接解出。並且不開辟額外的空間，也就是說空間復雜度是 O（1）

時間復雜度： O(N)

感謝 http://www.geeksforgeeks.org/connect-nodes-at-same-level-with-o1-extra-space/ 的作者

/*
    Solution 3: iterator with O(1) space.
    */
    public void connect(TreeLinkNode root) {
        if (root == null) {
            return;
        }

        connIterator(root);
    }

    /*
    This is a iterator version. 
    */
    public void connIterator(TreeLinkNode root) {
        TreeLinkNode leftEnd = root;
        while (leftEnd != null) {
            TreeLinkNode p = leftEnd;

            // Connect all the nodes in the next level together.
            while (p != null) {

                // find the 
                TreeLinkNode next = findLeftEnd(p.next);

                if (p.right != null) {
                    p.right.next = next;
                    next = p.right;
                }

                if (p.left != null) {
                    p.left.next = next;
                }

                // continue to deal with the next point.
                p = p.next;
            }

            // Find the left end of the NEXT LEVEL.
            leftEnd = findLeftEnd(leftEnd);
        }
        
    }

    // Find out the left end of the next level of Root TreeNode.
    public TreeLinkNode findLeftEnd(TreeLinkNode root) {
        while (root != null) {
            if (root.left != null) {
                return root.left;
            }

            if (root.right != null) {
                return root.right;
            }

            root = root.next;
        }

        return null;
    }

SOLUTION 4 (2014.1229):

在sol3基礎上改進，引入dummynode，我們就不需要先找到最左邊的點了。空間復雜度是 O（1）時間復雜度： O(N)

// SOLUTION 1: Iteration
    public void connect1(TreeLinkNode root) {
        if (root == null) {
            return;
        }
        
        TreeLinkNode leftEnd = root;
        
        // Bug 1: don't need " && leftEnd.left != null"
        while (leftEnd != null) {
            TreeLinkNode cur = leftEnd;
            
            TreeLinkNode dummy = new TreeLinkNode(0);
            TreeLinkNode pre = dummy;
            while (cur != null) {
                if (cur.left != null) {
                    pre.next = cur.left;
                    pre = cur.left;
                }
                
                if (cur.right != null) {
                    pre.next = cur.right;
                    pre = cur.right;
                }
                
                cur = cur.next;
            }
            leftEnd = dummy.next;
        }
    }

 

CODE ON GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/tree/Connect2_2014_1229.java

Connect2.java