[GeeksForGeeks] Connect binary tree nodes of same level

Given a binary tree with each node having one extra field of nextRight. nextRight points to the next right node of the same level.

Initially all nodes' nextRight field are set to null. Connect all nodes at the same level by setting each node's nextRight field.

Solution 1. O(n) runtime, O(n) space, level order traversal

This algorithm is the most straightforward solution.

class SpecialTreeNode {
    int val;
    SpecialTreeNode left;
    SpecialTreeNode right;
    SpecialTreeNode nextRight;
    SpecialTreeNode(int v) {
        val = v;
        left = null;
        right = null;
        nextRight = null;
    }
}
public class ConnectNodesOfSameLevel {

    public static void connectNodesLevelOrder(SpecialTreeNode root) {
        if(root == null) {
            return;
        }
        Queue<SpecialTreeNode> queue = new LinkedList<SpecialTreeNode>();
        queue.add(root);
        SpecialTreeNode prev = null, curr = null;
        
        while(!queue.isEmpty()) {
            prev = null;
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                curr = queue.poll();
                if(prev != null) {
                    prev.nextRight = curr;
                }
                if(curr.left != null) {
                    queue.add(curr.left);
                }
                if(curr.right != null) {
                    queue.add(curr.right);
                }
                prev = curr;
            }
        }
    }
}

Solution 2. O(n) runtime, O(height + width) space for recursion stack, a variation of pre-order traversal.

1. for the current node A, recursively set the left/right child nodes' nextRight of other nodes at the same level with A.

　This is done by recursively calling the connect method on A.nextRight.

2. then set A's left/right child nodes' nextRight. Since A's nextRight has already been set when processing the previous level,

    we use A's nextRight to find the next right node for A's left/right child nodes at A's children nodes' level.

public static void connectNodesRecursion(SpecialTreeNode root) {
    if(root == null) {
        return;
    }
    //set the nextRight of children nodes of other nodes at the same level
    connectNodesRecursion(root.nextRight);
    
    //set the nextRight of the current node's left/right child node
    if(root.left != null && root.right != null) {
        root.left.nextRight = root.right;
        root.right.nextRight = getNextRightNodeOfSameLevel(root);
        connectNodesRecursion(root.left);
    }
    else if(root.left != null) {
        root.left.nextRight = getNextRightNodeOfSameLevel(root);
        connectNodesRecursion(root.left);
    }
    else if(root.right != null) {
        root.right.nextRight = getNextRightNodeOfSameLevel(root);
        connectNodesRecursion(root.right);
    }
}
private static SpecialTreeNode getNextRightNodeOfSameLevel(SpecialTreeNode node) {
    if(node == null) {
        return null;
    }
    SpecialTreeNode temp = node.nextRight;
    while(temp != null && temp.left == null && temp.right == null) {
        temp = temp.nextRight;
    }
    if(temp == null) {
        return null;
    }
    else if(temp.left != null) {
        return temp.left;
    }
    return temp.right;
}

Solution 3. O(n) runtime, O(1) space, iterative implementation of solution 2.

The outer loop goes through all nodes' on the left edge of the given binary tree.

For each node A that the outer loop iterates, the inner loop goes through all nodes of the same level with A and 

sets each node's children nodes' nextRight field.

The core idea of both solution 2 and 3 is that when processing nodes at level k, their children nodes at level k + 1 

are updated with correct nextRight value. The algorithm is designed this way is because without using level order 

traversal, the only way of setting nextRight values level by level is to use the already set nextRight values from the 

previous level nodes.

public static void connectNodesIteration(SpecialTreeNode root) {
    if(root == null) {
        return;
    }
    SpecialTreeNode leftMost = root, curr = null;
    leftMost.nextRight = null;
    
    while(leftMost != null) {
        curr = leftMost;
        while(curr != null) {
            if(curr.left != null && curr.right != null) {
                curr.left.nextRight = curr.right;
                curr.right.nextRight = getNextRightNodeOfSameLevel(curr);
            }
            else if(curr.left != null) {
                curr.left.nextRight = getNextRightNodeOfSameLevel(curr);
            }
            else if(curr.right != null) {
                curr.right.nextRight = getNextRightNodeOfSameLevel(curr);
            }
            curr = curr.nextRight;
        }            
        leftMost = leftMost.left;
    }
}