leetcode--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

分类：二叉树

题意：对于每个节点，将next指向其右边的相邻节点，如果右边没有节点，则指向Null。该树为任意二叉树。

解法1：层次遍历。使用两个栈来交替记录两层。对于每个层，逐一连接即可。

/**
 * 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;  
        Stack<TreeLinkNode> stack1 = new Stack<TreeLinkNode>();  
        List<TreeLinkNode> stack2 = new ArrayList<TreeLinkNode>();  
        stack1.add(root);  
        while(stack1.size()>0||stack2.size()>0){            
            TreeLinkNode pre = null;  
            while(stack1.size()>0){  
                TreeLinkNode t = stack1.pop();        
                if(t.left!=null) stack2.add(t.left);  
                if(t.right!=null) stack2.add(t.right);  
                if(pre!=null){  
                    pre.next = t;                     
                }  
                pre = t;  
            }  
            Collections.reverse(stack2);  
            stack1.addAll(stack2);  
            stack2.clear();  
        }  
    }
}

解法2：层次遍历，和Populating Next Right Pointers in Each Node里面的解法类似，主要问题是，1，找到下一层开始的第一个节点；2，找到当前节点右边的第一个节点

/**
 * 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 cur = root;//上一层第一个节点
        TreeLinkNode start = null;
        root.next = null;
        while(root!=null){//没有到最后一层的第一个节点
            start = findStart(root);//当前层第一个节点           
            cur = start;            
            while(cur!=null){//遍历当前层
               cur.next = findNext(root,cur);
               cur = cur.next;
            }           
            root = start;//当前层第一个节点
        }
    }
    
    public TreeLinkNode findStart(TreeLinkNode root){//找到下一层的第一个节点
        while(root!=null){
            if(root.left!=null) return root.left;
            if(root.right!=null) return root.right;
            root = root.next;
        }
        return null;
    }
    
    public TreeLinkNode findNext(TreeLinkNode root,TreeLinkNode cur){//找到当前节点右边的第一个节点
        while(root!=null){//找到当前节点父节点
            if(root.left==cur||root.right==cur) break;
            root = root.next;           
        }       
        if(root.right==cur) root=root.next;//如果当前节点在父节点的右边，将root指向它的右边 
        while(root!=null){
            if(root.left!=cur&&root.left!=null) return root.left;
            if(root.right!=cur&&root.right!=null) return root.right;
            root = root.next;
        }
        return null;
    }
}

解法3：层次遍历。关键在于保留下一层的第一个节点。另外保留一个pre指向前一个节点。

/**
 * 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 cur = root;//上一层第一个节点
        while(root!=null){//没有到最后一层的第一个节点
            cur = root;
            TreeLinkNode temp = new TreeLinkNode(-1);//该节点用于保存下一层的第一个节点           
            TreeLinkNode pre = temp;
            while(cur!=null){//遍历当前层
               if(cur.left!=null){
                   pre.next = cur.left;
                   pre = pre.next;
               }
               if(cur.right!=null){
                   pre.next = cur.right;
                   pre = pre.next;
               }
               cur = cur.next;
            }           
            root = temp.next;//下一层的第一个节点
        }
    }
}

解法4：将解法3的迭代换成递归

/**
 * 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 temp = new TreeLinkNode(-1);           
        TreeLinkNode pre = temp;
        while(root!=null){//遍历当前层
           if(root.left!=null){
               pre.next = root.left;
               pre = pre.next;
           }
           if(root.right!=null){
               pre.next = root.right;
               pre = pre.next;
           }
           root = root.next;
        }           
        connect(temp.next);//连接下一层
    }
}