medium Connect 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 a null node.

Examples

Example 1:

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

• Output:

  [1 -> null]
  [2 -> 3 -> null]
  [4 -> 5 -> 6 -> 7 -> null]
  

• Explanation:
  The tree is traversed level by level using BFS. Each node is connected to its next right node at the same level. The last node of each level points to null.

Example 2:

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

• Output:

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

• Explanation:
  The nodes are connected to their next right sibling at the same level. The last node of each level points to null.

Constraints:

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

Solution

To solve this problem, we perform a level order traversal using Breadth-First Search (BFS) while connecting each node to its immediate right neighbor within the same level. We use a queue to keep track of nodes at each level and maintain a previousNode pointer to establish connections. At the start of each level, previousNode is set to null. As we process nodes within the level, we link previousNode.next to the currentNode, ensuring all siblings are connected. The previousNode is then updated to the currentNode for subsequent connections. Once a node is processed, its left and right children are enqueued so they are available in the next level. The last node of each level remains pointing to null, marking the end of the level's linked sequence.

This approach ensures that all nodes within the same level are properly connected while preserving the correct order of traversal. Once all levels are processed, the modified tree is returned.

Step-by-Step Algorithm

1. Handle the Base Case:

   • If the root is null, return null immediately.

2. Initialize BFS:

   • Create a queue and enqueue the root node.

3. Process Each Level Iteratively:

   • While the queue is not empty:
     • Determine levelSize, the number of nodes in the current level.
     • Initialize previousNode as null to keep track of the last processed node.

4. Connect Nodes in the Current Level:

   • Iterate over all nodes in the current level:
     • Dequeue the front node.
     • If previousNode is not null, set previousNode.next = currentNode to connect them.
     • Update previousNode to currentNode to store previously processed node for the next level.
     • Enqueue the left and right children (if they exist).

5. Move to the Next Level and Repeat Until the Queue is Empty.

6. Return the Modified Tree Root.

Algorithm Walkthrough

1. Initialize BFS Traversal:

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

   Queue: [12]

2. Process Level 1 (Root Level):

   • Level Size: 1 (only node 12 in this level).
   • Initialize previousNode = null.
   • 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 (last node in level points to null)

3. Process Level 2:

   • Level Size: 2 (nodes 7 and 1).
   • Initialize previousNode = null.
   • Dequeue 7:
     • Since previousNode is null, assign previousNode = 7.
     • Enqueue left child 9 (no right child for 7).
   • Dequeue 1:
     • Connect 7.next = 1 (link the previous node to the current node).
     • Update previousNode = 1.
     • Enqueue left child 10.
     • Enqueue right child 5.

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

4. Process Level 3:

   • Level Size: 3 (nodes 9, 10, 5).
   • Initialize previousNode = null.
   • Dequeue 9:
     • Since previousNode is null, assign previousNode = 9.
     • 9 has no children, so nothing is enqueued.
   • Dequeue 10:
     • Connect 9.next = 10 (link the previous node to the current node).
     • Update previousNode = 10.
     • 10 has no children, so nothing is enqueued.
   • Dequeue 5:
     • Connect 10.next = 5 (link the previous node to the current node).
     • Update previousNode = 5.
     • 5 has no children, so nothing is enqueued.

   Queue after processing: [] (No more nodes to process).
   Next Pointer Connections: 9 -> 10 -> 5 -> null

Final Connected Tree

        12 -> null
       /   \
      7  -> 1 -> null
     /    /   \
    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);
    while (!queue.isEmpty()) {
      TreeNode previousNode = null;
      int levelSize = queue.size();
      // connect all nodes of this level
      for (int i = 0; i < levelSize; i++) {
        TreeNode 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;
  }

  // level order traversal using 'next' pointer
  public static void printLevelOrder(TreeNode root) {
    TreeNode nextLevelRoot = root;
    while (nextLevelRoot != null) {
      TreeNode current = nextLevelRoot;
      nextLevelRoot = null;
      while (current != null) {
        System.out.print(current.val + " ");
        if (nextLevelRoot == null) {
          if (current.left != null) nextLevelRoot = current.left;
          else if (current.right != null) nextLevelRoot = current.right;
        }
        current = current.next;
      }
      System.out.println();
    }
  }

  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);
    root = sol.connect(root);
    System.out.println("Level order traversal using 'next' pointer: ");
    printLevelOrder(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 nodes at any level (this could happen only at the lowest level), therefore we will need space to store them in the queue.