LeetCode 117. Populating Next Right Pointers in Each Node II（右邻）

原题网址：https://leetcode.com/problems/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

方法一：对于每个节点，寻找所有的深度的子节点，直到找完全部。

/**
 * Definition for binary tree with next pointer.
 * public class TreeLinkNode {
 *     int val;
 *     TreeLinkNode left, right, next;
 *     TreeLinkNode(int x) { val = x; }
 * }
 */
public class Solution {
    private TreeLinkNode leftmost(TreeLinkNode root, int depth) {
        if (root == null || depth == 0) return root;
        TreeLinkNode leftmost = leftmost(root.left, depth-1);
        if (leftmost != null) return leftmost;
        leftmost = leftmost(root.right, depth-1);
        return leftmost;
    }
    private TreeLinkNode rightmost(TreeLinkNode root, int depth) {
        if (root == null || depth == 0) return root;
        TreeLinkNode rightmost = rightmost(root.right, depth-1);
        if (rightmost != null) return rightmost;
        rightmost = rightmost(root.left, depth-1);
        return rightmost;
    }
    public void connect(TreeLinkNode root) {
        if (root == null) return;
        if (root.left != null) connect(root.left);
        if (root.right != null) connect(root.right);
        for(int i=1;; i++) {
            TreeLinkNode left = rightmost(root.left, i-1);
            if (left == null) break;
            TreeLinkNode right = leftmost(root.right, i-1);
            if (right == null) break;
            left.next = right;
        }
    }
}

方法二：利用子问题，层层连接。

/**
 * 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) {
        TreeLinkNode upper = root;
        TreeLinkNode leftmost = null;
        TreeLinkNode bottom = null;
        while (upper != null) {
            while (upper != null) {
                if (upper.left != null && bottom != upper.left && (upper.right == null || bottom != upper.right)) {
                    if (leftmost == null) {
                        leftmost = upper.left;
                        bottom = leftmost;
                    } else {
                        bottom.next = upper.left;
                        bottom = bottom.next;
                    }
                } else if (upper.right != null && bottom != upper.right) {
                    if (leftmost == null) {
                        leftmost = upper.right;
                        bottom = leftmost;
                    } else {
                        bottom.next = upper.right;
                        bottom = bottom.next;
                    }
                } else {
                    upper = upper.next;
                }
            }
            upper = leftmost;
            leftmost = null;
            bottom = null;
        }
    }
}

如果使用辅助链表头会简化很多：

/**
 * 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) {
        TreeLinkNode current = root;
        while (current != null) {
            TreeLinkNode next = new TreeLinkNode(0);
            TreeLinkNode tail = next;
            while (current != null) {
                if (current.left != null) {
                    tail.next = current.left;
                    tail = tail.next;
                }
                if (current.right != null) {
                    tail.next = current.right;
                    tail = tail.next;
                }
                current = current.next;
            }
            current = next.next;
        }
    }
}