Populating Next Right Pointers in Each Node I, II

Given a binary tree

    struct TreeLinkNode {
      TreeLinkNode *left;
      TreeLinkNode *right;
      TreeLinkNode *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.

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

-----------------------------

一我觉得还是很简单的，因为是perfect的binary tree，所以是有规律可循的，并不需要直接用BFS来解决。

所以通过找left和right的规律，我们就可以完成这个code，当然，还是得recursive：

/**
 * 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;
        if(root.left!=null){
            root.left.next = root.right;
        }
        if(root.right!=null){
            root.right.next = root.next==null? null:root.next.left;
        }
        
        connect(root.left);
        connect(root.right);
    }
}

——————————————————————————————————

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

这次就变得很麻烦了，因为这棵树可能长成这样：

   1 -> NULL
       /  \
      2 -> 3 -> NULL
     /      \
    4   ->   7 -> NULL

       
相当最下面一层隔着很多的element，已经不能单纯地通过找规律来完成了。但是问题也不难，只要BFS就可以了。

import java.util.LinkedList;
public class PopNextRightPoII {
	//I guess BFS will work out
	public void connect(TreeLinkNode root) {
        if(root==null)
			return;
		LinkedList<TreeLinkNode> queue = new LinkedList<TreeLinkNode>();
		queue.offer(root);
		while(queue.size()!=0){
		    int size = queue.size();//you need to remember the size before poll, otherwise size changes
			TreeLinkNode pre = null;
			for(int i=0;i<size;i++){
				TreeLinkNode curr = queue.poll();
				if(pre!=null){
					pre.next=curr;
				} 
				pre = curr;
				if(curr.left!=null){
					queue.offer(curr.left);
				}
				if(curr.right!=null){
					queue.offer(curr.right);
				}
			}
			pre.next = null;//this is important. don't forget to add null to rightest one.
		}
    }
	
	
	 public class TreeLinkNode {
		     int val;
		     TreeLinkNode left, right, next;
		     TreeLinkNode(int x) { val = x; }
		 }
}