medium Connect All Level Order Siblings

Problem Statement

Given a root of the binary tree, connect each node with its level order successor. The last node of each level should point to the first node of the next level.

Examples

Example 1

• Input: root = [1, 2, 3, 4, 5, 6, 7]

• Output: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> null
• Explanation: The tree is traversed level by level using BFS. Each node is connected to its next node in level order traversal, including connections between levels. The last node (7) points to null.

Example 2

• Input: root = [12, 7, 1, 9, null, 10, 5]

• Output: 12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null
• Explanation: Each node is connected to its next node in level order traversal. The last node (5) points to null, completing the connection of all level order siblings.

Constraints:

• The number of nodes in the tree is in the range [0, 2¹² - 1].
• -1000 <= Node.val <= 1000

Solution

In the previous problem, we connected nodes within the same level. Here, we extend the connection across levels, linking every node to its next node in level order traversal. Using BFS, we process nodes one by one, maintaining a previousNode to link the dequeued node. The last node in traversal points to null, forming a single linked list that follows the tree’s level order sequence.

Step-by-Step Algorithm

1. Handle the Base Case:

   • If the tree is empty (root == null), return null.

2. Initialize BFS Traversal:

   • Create a queue and enqueue the root node to start the level order traversal.
   • Define previousNode = null to track the last processed node and establish connections.
   • Define currentNode to hold the node dequeued at each step.

3. Process Nodes One by One:

   • While the queue is not empty:
     • Dequeue the front node and store it in currentNode.
     • If previousNode is not null, connect previousNode.next = currentNode to maintain level order linking.
     • Update previousNode = currentNode to track the last processed node.

4. Enqueue the Children of the Current Node:

   • If currentNode.left exists, enqueue it.
   • If currentNode.right exists, enqueue it.

5. Continue Until All Nodes Are Processed.

   • The last node in traversal will automatically point to null, marking the end of the sequence.

6. Return the Root Node After All Connections Are Established.

Algorithm Walkthrough

1. Initialize BFS Traversal:

   • Start with the root node 12.
   • Initialize an empty queue and enqueue 12.
   • Initialize previousNode = null.

   Queue: [12]

2. Process Node 12:

   • Dequeue 12:
     • Since previousNode is null, assign previousNode = 12.
     • Enqueue left child 7.
     • Enqueue right child 1.

   Queue after processing: [7, 1]
   Next Pointer Connection: 12 -> null

3. Process Node 7:

   • Dequeue 7:
     • Connect 12.next = 7 (link 12 to 7).
     • Update previousNode = 7.
     • Enqueue left child 9 (no right child).

   Queue after processing: [1, 9]
   Next Pointer Connections: 12 -> 7 -> null

4. Process Node 1:

   • Dequeue 1:
     • Connect 7.next = 1 (link 7 to 1).
     • Update previousNode = 1.
     • Enqueue left child 10.
     • Enqueue right child 5.

   Queue after processing: [9, 10, 5]
   Next Pointer Connections: 12 -> 7 -> 1 -> null

5. Process Node 9:

   • Dequeue 9:
     • Connect 1.next = 9 (link 1 to 9).
     • Update previousNode = 9.
     • 9 has no children.

   Queue after processing: [10, 5]
   Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> null

6. Process Node 10:

   • Dequeue 10:
     • Connect 9.next = 10 (link 9 to 10).
     • Update previousNode = 10.
     • 10 has no children.

   Queue after processing: [5]
   Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> 10 -> null

7. Process Node 5:

   • Dequeue 5:
     • Connect 10.next = 5 (link 10 to 5).
     • Update previousNode = 5.
     • 5 has no children.

   Queue after processing: []
   Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null

Final Connected Tree Representation

12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null

Code

Here is the code for this algorithm:

import java.util.*;

// class TreeNode {
//   int val;
//   TreeNode left;
//   TreeNode right;
//   TreeNode next;

//   TreeNode(int x) {
//     val = x;
//     left = right = next = null;
//   }
// };

class Solution {
  public TreeNode connect(TreeNode root) {
    if (root == null)
      return root;

    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    TreeNode currentNode = null, previousNode = null;
    while (!queue.isEmpty()) {
      currentNode = queue.poll();
      if (previousNode != null)
        previousNode.next = currentNode;
      previousNode = currentNode;

      // insert the children of current node in the queue
      if (currentNode.left != null)
        queue.offer(currentNode.left);
      if (currentNode.right != null)
        queue.offer(currentNode.right);
    }
    return root;
  }

  // tree traversal using 'next' pointer
  public void printTree(TreeNode root) {
    TreeNode current = root;
    System.out.print("Traversal using 'next' pointer: ");
    while (current != null) {
      System.out.print(current.val + " ");
      current = current.next;
    }
  }

  public static void main(String[] args) {
    Solution sol = new Solution();
    TreeNode root = new TreeNode(12);
    root.left = new TreeNode(7);
    root.right = new TreeNode(1);
    root.left.left = new TreeNode(9);
    root.right.left = new TreeNode(10);
    root.right.right = new TreeNode(5);
    sol.connect(root);
    sol.printTree(root);
  }
}

Complexity Analysis

Time Complexity

The time complexity of the above algorithm is , where ‘N’ is the total number of nodes in the tree. This is due to the fact that we traverse each node once.

Space Complexity

The space complexity of the above algorithm will be which is required for the queue. Since we can have a maximum of N/2 nodes at any level (this could happen only at the lowest level), therefore we will need space to store them in the queue.