Connect all nodes to their Left Neighbors in a Binary Tree

Given a Binary Tree, where each node contains an extra empty pointer initially null. The task is to connect all nodes of the binary tree to their left neighbour at the same level using this extra pointer.

Examples:

Input : 
       A
      / \
     B   C
    / \   \
   D   E   F
Output :
       NULL<--A
             / \
     NULL<--B<--C
           / \   \
   NULL<--D<--E<--F

Approach:
We can use Pre-order traversal of tree passing the level of the node at each call. The root node is at level 0. While traversing we store the recently seen node at that level in an array of node pointers. The pre-order traversal ensures that the node in the array at a particular level is left neighbour of upcoming node at the same level.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to connect nodes
// at same level using extended
// pre-order traversal
  
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
  
// Binary tree node, with extra pointer leftNeighbour
// to store the neighbour to left nodes
class node {
public:
    int data;
    node* left;
    node* right;
    node* leftNeighbour;
  
    /* Constructor that allocates a new node with the 
       given data and NULL left and right pointers. */
    node(int data)
    {
        this->data = data;
        this->left = NULL;
        this->right = NULL;
        this->leftNeighbour = NULL;
    }
};
  
// Array to store the recent visited 
// node at particulat level represented 
// by indices
node* a[100];
  
// Function to connect nodes using preorder 
// traversal
void connectNodes(node* p, int l)
{
    if (p == NULL)
        return;
  
    // assigning left neighbor
    p->leftNeighbour = a[l];
  
    // updating value of the recent 
    // node at level
    a[l] = p;
    connectNodes(p->left, l + 1);
    connectNodes(p->right, l + 1);
}
  
// Utility function to connect nodes to neighbours
// using preorder traversal
void connectNodesUtil(node* root)
{   
    // Initalize nodes at every level to NULL
    for (int i = 0; i < 100; i++)
        a[i] = NULL;
          
    // Populates next left pointer in all nodes
    connectNodes(root, 0);
      
    // Let us check the values of next left pointers
    cout << "Following are populated leftNeighbour"
            <<" pointers in the tree:\n";
              
    cout << "leftNeighbour of " << root->data << " is "
            << (root->leftNeighbour ? 
                root->leftNeighbour->data : -1) << endl;
                  
    cout << "leftNeighbour of " << root->left->data << " is "
            << (root->left->leftNeighbour ?
                root->left->leftNeighbour->data : -1) << endl;
                  
    cout << "leftNeighbour of " << root->right->data << " is "
            << (root->right->leftNeighbour ? 
                root->right->leftNeighbour->data : -1) << endl;
                  
    cout << "leftNeighbour of " << root->left->left->data << " is "
            << (root->left->left->leftNeighbour ? 
                root->left->left->leftNeighbour->data : -1) << endl;
}
  
// Driver Code
int main()
{
  
    /* Constructed binary tree is 
            10 
            / \ 
           8   2 
          
         
    */
    node* root = new node(10);
    root->left = new node(8);
    root->right = new node(2);
    root->left->left = new node(3);
  
    connectNodesUtil(root);
      
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to connect nodes
// at same level using extended
// pre-order traversal
import java.util.*;
  
class GFG
{
  
// Binary tree node, with extra pointer leftNeighbour
// to store the neighbour to left nodes
static class node 
{
    int data;
    node left;
    node right;
    node leftNeighbour;
  
    /* Constructor that allocates a new node with the 
    given data and null left and right pointers. */
    node(int data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
        this.leftNeighbour = null;
    }
}
  
// Array to store the recent visited 
// node at particulat level represented 
// by indices
static node a[] = new node[100];
  
// Function to connect nodes using preorder 
// traversal
static void connectNodes(node p, int l)
{
    if (p == null)
        return;
  
    // assigning left neighbor
    p.leftNeighbour = a[l];
  
    // updating value of the recent 
    // node at level
    a[l] = p;
    connectNodes(p.left, l + 1);
    connectNodes(p.right, l + 1);
}
  
// Utility function to connect nodes to neighbours
// using preorder traversal
static void connectNodesUtil(node root)
    // Initalize nodes at every level to null
    for (int i = 0; i < 100; i++)
        a[i] = new node(-1);
          
    // Populates next left pointer in all nodes
    connectNodes(root, 0);
      
    // Let us check the values of next left pointers
    System.out.println( "Following are populated leftNeighbour"
                        " pointers in the tree:");
              
    System.out.println( "leftNeighbour of " + root.data + 
                        " is " + (root.leftNeighbour != null
                                  root.leftNeighbour.data : -1));
                  
    System.out.println( "leftNeighbour of " + root.left.data + 
                        " is " + (root.left.leftNeighbour != null ?
                                  root.left.leftNeighbour.data : -1));
                  
    System.out.println( "leftNeighbour of " + root.right.data + 
                        " is " + (root.right.leftNeighbour != null
                                  root.right.leftNeighbour.data : -1) );
                  
    System.out.println( "leftNeighbour of " + root.left.left.data + 
                        " is " + (root.left.left.leftNeighbour != null
                                  root.left.left.leftNeighbour.data : -1));
}
  
// Driver Code
public static void main(String args[])
{
  
    /* Constructed binary tree is 
            10 
            / \ 
        8 2 
        
        
    */
    node root = new node(10);
    root.left = new node(8);
    root.right = new node(2);
    root.left.left = new node(3);
  
    connectNodesUtil(root);
}
}
  
// This code is contributed by Arnab Kundu

chevron_right


Output:

Following are populated leftNeighbour pointers in the tree:
leftNeighbour of 10 is -1
leftNeighbour of 8 is -1
leftNeighbour of 2 is 8
leftNeighbour of 3 is -1

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : andrew1234

Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.