Given a Binary Tree, The task is to connect all the adjacent nodes at the same level starting from the left-most node of that level, and ending at the right-most node using nextRight pointer by setting these pointers to point the next right for each node.
Examples:
Input:
1
/ \
2 3
/ \ \
4 5 6Output:
1—>NULL
/ \
2–>3–>NULL
/ \ \
4–>5–>6–>NULLInput:
10
/ \
12 15
/ \ \
5 4 3Output:
10—>NULL
/ \
12–>15–>NULL
/ \ \
5–>4–>3–>NULL
Below is the idea to solve the problem
Traverse the tree using Breadth first search traversal and maintain a prev pointer initialized with NULL, firstly point it to root then every time a new node is traversed set prev’s nextRight to current node and move prev to prev’s next.
Follow the below steps to Implement the idea:
- Initialize a node pointer Prev to NULL and a queue of node pointer Q.
- Traverse the tree in Breadth-first search order starting from the root.
- Calculate the size sz of the Q and run a for loop from 0 to sz – 1.
- If prev is Null then set prev to the current node.
- Else set prev’s next to the current node and prev to the current node.
- Set prev’s next to Null and prev to Null.
- If the current node’s left is not null push it into the queue.
- If the current node’s right is not null push it into the queue.
- Calculate the size sz of the Q and run a for loop from 0 to sz – 1.
Below is the Implementation of the above approach:
C++
/* Iterative program to connect all the adjacent nodes at * the same level in a binary tree*/
#include <iostream>#include <queue>using namespace std;
// A Binary Tree Nodeclass node {
public:
int data;
node* left;
node* right;
node* nextRight;
/* 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->nextRight = NULL;
}
};// setting right pointer to next right node/* 10 ----------> NULL
/ \
8 --->2 --------> NULL
/
3 ----------------> NULL
*/
void connect(node* root)
{ // Base condition
if (root == NULL)
return;
// Create an empty queue like level order traversal
queue<node*> q;
q.push(root);
while (!q.empty()) {
// size indicates no. of nodes at current level
int size = q.size();
// for keeping track of previous node
node* prev = NULL;
while (size--) {
node* temp = q.front();
q.pop();
if (temp->left)
q.push(temp->left);
if (temp->right)
q.push(temp->right);
if (prev != NULL)
prev->nextRight = temp;
prev = temp;
}
prev->nextRight = NULL;
}
}int main()
{ /* Constructed binary tree is
10
/ \
8 2
/
3
*/
// Let us create binary tree shown above
node* root = new node(10);
root->left = new node(8);
root->right = new node(2);
root->left->left = new node(3);
connect(root);
// Let us check the values
// of nextRight pointers
cout << "Following are populated nextRight pointers in "
"the tree"
" (-1 is printed if there is no nextRight)\n";
cout << "nextRight of " << root->data << " is "
<< (root->nextRight ? root->nextRight->data : -1)
<< endl;
cout << "nextRight of " << root->left->data << " is "
<< (root->left->nextRight
? root->left->nextRight->data
: -1)
<< endl;
cout << "nextRight of " << root->right->data << " is "
<< (root->right->nextRight
? root->right->nextRight->data
: -1)
<< endl;
cout << "nextRight of " << root->left->left->data
<< " is "
<< (root->left->left->nextRight
? root->left->left->nextRight->data
: -1)
<< endl;
return 0;
}// this code is contributed by Kapil Poonia |
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node left, right, nextRight;
Node(int item)
{
data = item;
left = right = nextRight = null;
}
}public class BinaryTree {
Node root;
void connect(Node p)
{
// initialize queue to hold nodes at same level
Queue<Node> q = new LinkedList<>();
q.add(root); // adding nodes to the queue
Node temp = null; // initializing prev to null
while (!q.isEmpty()) {
int n = q.size();
for (int i = 0; i < n; i++) {
Node prev = temp;
temp = q.poll();
// i > 0 because when i is 0 prev points
// the last node of previous level,
// so we skip it
if (i > 0)
prev.nextRight = temp;
if (temp.left != null)
q.add(temp.left);
if (temp.right != null)
q.add(temp.right);
}
// pointing last node of the nth level to null
temp.nextRight = null;
}
}
// Driver program to test above functions
public static void main(String args[])
{
BinaryTree tree = new BinaryTree();
/* Constructed binary tree is
10
/ \
8 2
/
3
*/
tree.root = new Node(10);
tree.root.left = new Node(8);
tree.root.right = new Node(2);
tree.root.left.left = new Node(3);
// Populates nextRight pointer in all nodes
tree.connect(tree.root);
// Let us check the values of nextRight pointers
System.out.println(
"Following are populated nextRight pointers in "
+ "the tree"
+ "(-1 is printed if there is no nextRight)");
int a = tree.root.nextRight != null
? tree.root.nextRight.data
: -1;
System.out.println("nextRight of " + tree.root.data
+ " is " + a);
int b = tree.root.left.nextRight != null
? tree.root.left.nextRight.data
: -1;
System.out.println("nextRight of "
+ tree.root.left.data + " is "
+ b);
int c = tree.root.right.nextRight != null
? tree.root.right.nextRight.data
: -1;
System.out.println("nextRight of "
+ tree.root.right.data + " is "
+ c);
int d = tree.root.left.left.nextRight != null
? tree.root.left.left.nextRight.data
: -1;
System.out.println("nextRight of "
+ tree.root.left.left.data
+ " is " + d);
}
}// This code has been contributed by Rahul Shakya |
Python3
# Iterative program to connect all the adjacent nodes at the same level in a binary treeclass newnode:
def __init__(self, data):
self.data = data
self.left = self.right = self.nextRight = None
# setting right pointer to next right node# 10 ----------> NULL# / \# 8 --->2 --------> NULL# /# 3 ----------------> NULLdef connect(root):
# Base condition
if root is None:
return
# Create an empty queue like level order traversal
queue = []
queue.append(root)
while len(queue) != 0:
# size indicates no. of nodes at current level
size = len(queue)
# for keeping track of previous node
prev = newnode(None)
for i in range(size):
temp = queue.pop(0)
if temp.left:
queue.append(temp.left)
if temp.right:
queue.append(temp.right)
if prev != None:
prev.nextRight = temp
prev = temp
prev.nextRight = None
# Driver Codeif __name__ == '__main__':
# Constructed binary tree is
# 10
# / \
# 8 2
# /
# 3
root = newnode(10)
root.left = newnode(8)
root.right = newnode(2)
root.left.left = newnode(3)
# Populates nextRight pointer in all nodes
connect(root)
# Let us check the values of nextRight pointers
print("Following are populated nextRight",
"pointers in the tree (-1 is printed",
"if there is no nextRight)")
print("nextRight of", root.data, "is ", end="")
if root.nextRight:
print(root.nextRight.data)
else:
print(-1)
print("nextRight of", root.left.data, "is ", end="")
if root.left.nextRight:
print(root.left.nextRight.data)
else:
print(-1)
print("nextRight of", root.right.data, "is ", end="")
if root.right.nextRight:
print(root.right.nextRight.data)
else:
print(-1)
print("nextRight of", root.left.left.data, "is ", end="")
if root.left.left.nextRight:
print(root.left.left.nextRight.data)
else:
print(-1)
# This code is contributed by Vivek Maddeshiya |
C#
// C# program to connect nodes// at same levelusing System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right, nextRight;
public Node(int item)
{
data = item;
left = right = nextRight = null;
}
}public class BinaryTree {
Node root;
void connect(Node p)
{
// initialize queue to hold nodes at same level
Queue<Node> q = new Queue<Node>();
q.Enqueue(root); // adding nodes to the queue
Node temp = null; // initializing prev to null
while (q.Count > 0) {
int n = q.Count;
for (int i = 0; i < n; i++) {
Node prev = temp;
temp = q.Dequeue();
// i > 0 because when i is 0 prev points
// the last node of previous level,
// so we skip it
if (i > 0)
prev.nextRight = temp;
if (temp.left != null)
q.Enqueue(temp.left);
if (temp.right != null)
q.Enqueue(temp.right);
}
// pointing last node of the nth level to null
temp.nextRight = null;
}
}
// Driver code
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
/* Constructed binary tree is
10
/ \
8 2
/
3
*/
tree.root = new Node(10);
tree.root.left = new Node(8);
tree.root.right = new Node(2);
tree.root.left.left = new Node(3);
// Populates nextRight pointer in all nodes
tree.connect(tree.root);
// Let us check the values of nextRight pointers
Console.WriteLine(
"Following are populated nextRight pointers in "
+ "the tree"
+ "(-1 is printed if there is no nextRight)");
int a = tree.root.nextRight != null
? tree.root.nextRight.data
: -1;
Console.WriteLine("nextRight of " + tree.root.data
+ " is " + a);
int b = tree.root.left.nextRight != null
? tree.root.left.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.left.data + " is "
+ b);
int c = tree.root.right.nextRight != null
? tree.root.right.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.right.data + " is "
+ c);
int d = tree.root.left.left.nextRight != null
? tree.root.left.left.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.left.left.data
+ " is " + d);
Console.ReadKey();
}
}// This code has been contributed by techno2mahi |
Javascript
<script>class Node { constructor(item)
{
this.data = item;
this.left = this.right = this.nextRight = null;
}
}let root;function connect(p)
{ // initialize queue to hold nodes at same level
let q = [];
q.push(root); // adding nodes to the queue
let temp = null; // initializing prev to null
while (q.length!=0) {
let n = q.length;
for (let i = 0; i < n; i++) {
let prev = temp;
temp = q.shift();
// i > 0 because when i is 0 prev points
// the last node of previous level,
// so we skip it
if (i > 0)
prev.nextRight = temp;
if (temp.left != null)
q.push(temp.left);
if (temp.right != null)
q.push(temp.right);
}
// pointing last node of the nth level to null
temp.nextRight = null;
}
}// Driver program to test above functions/* Constructed binary tree is 10
/ \
8 2
/
3
*/
root = new Node(10);
root.left = new Node(8);
root.right = new Node(2);
root.left.left = new Node(3);
// Populates nextRight pointer in all nodesconnect(root);// Let us check the values of nextRight pointersdocument.write("Following are populated nextRight pointers in "
+ "the tree"
+ "(-1 is printed if there is no nextRight)<br>");
let a = root.nextRight != null ? root.nextRight.data : -1;
document.write("nextRight of " + root.data + " is "
+ a+"<br>");
let b = root.left.nextRight != null ? root.left.nextRight.data : -1;
document.write("nextRight of " + root.left.data + " is "
+ b+"<br>");
let c = root.right.nextRight != null ? root.right.nextRight.data : -1;
document.write("nextRight of " + root.right.data + " is "
+ c+"<br>");
let d = root.left.left.nextRight != null ? root.left.left.nextRight.data : -1;
document.write("nextRight of " + root.left.left.data + " is "
+ d+"<br>");
// This code is contributed by avanitrachhadiya2155</script> |
Output
Following are populated nextRight pointers in the tree (-1 is printed if there is no nextRight) nextRight of 10 is -1 nextRight of 8 is 2 nextRight of 2 is -1 nextRight of 3 is -1
Time Complexity: O(N)
Auxiliary Space: O(N)
Connect nodes at the same level using Pre Order Traversal:
This approach works only for Complete Binary Trees. In this method we set nextRight in Pre Order fashion to make sure that the nextRight of parent is set before its children. When we are at node p, we set the nextRight of its left and right children. Since the tree is complete tree, nextRight of p’s left child (p->left->nextRight) will always be p’s right child, and nextRight of p’s right child (p->right->nextRight) will always be left child of p’s nextRight (if p is not the rightmost node at its level). If p is the rightmost node, then nextRight of p’s right child will be NULL.
Follow the below steps to Implement the idea:
- Set root ->nextRight to NULL.
- Call for a recursive function of root.
- If root -> left is not NULL then set root -> left -.> nextRight = root -> right
- If root -> right is not NULL then
- If root -> nextRight is not NULL set root -> right -.> nextRight = root -> nextRight -> left.
- Else set root -> right -.> nextRight to NULL.
- recursively call for left of root
- recursively call for right of root
Below is the Implementation of the above approach:
C++
// CPP program to connect nodes// at same level using extended// pre-order traversal#include <bits/stdc++.h>#include <iostream>using namespace std;
class node {
public:
int data;
node* left;
node* right;
node* nextRight;
/* 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->nextRight = NULL;
}
};void connectRecur(node* p);
// Sets the nextRight of// root and calls connectRecur()// for other nodesvoid connect(node* p)
{ // Set the nextRight for root
p->nextRight = NULL;
// Set the next right for rest of the nodes
// (other than root)
connectRecur(p);
}/* Set next right of all descendants of p.Assumption: p is a complete binary tree */void connectRecur(node* p)
{ // Base case
if (!p)
return;
// Set the nextRight pointer for p's left child
if (p->left)
p->left->nextRight = p->right;
// Set the nextRight pointer
// for p's right child p->nextRight
// will be NULL if p is the right
// most child at its level
if (p->right)
p->right->nextRight
= (p->nextRight) ? p->nextRight->left : NULL;
// Set nextRight for other
// nodes in pre order fashion
connectRecur(p->left);
connectRecur(p->right);
}/* Driver code*/int main()
{ /* Constructed binary tree is
10
/ \
8 2
/
3
*/
node* root = new node(10);
root->left = new node(8);
root->right = new node(2);
root->left->left = new node(3);
// Populates nextRight pointer in all nodes
connect(root);
// Let us check the values
// of nextRight pointers
cout << "Following are populated nextRight pointers in "
"the tree"
" (-1 is printed if there is no nextRight)\n";
cout << "nextRight of " << root->data << " is "
<< (root->nextRight ? root->nextRight->data : -1)
<< endl;
cout << "nextRight of " << root->left->data << " is "
<< (root->left->nextRight
? root->left->nextRight->data
: -1)
<< endl;
cout << "nextRight of " << root->right->data << " is "
<< (root->right->nextRight
? root->right->nextRight->data
: -1)
<< endl;
cout << "nextRight of " << root->left->left->data
<< " is "
<< (root->left->left->nextRight
? root->left->left->nextRight->data
: -1)
<< endl;
return 0;
}// This code is contributed by rathbhupendra |
C
// C program to connect nodes at same level using extended// pre-order traversal#include <stdio.h>#include <stdlib.h>struct node {
int data;
struct node* left;
struct node* right;
struct node* nextRight;
};void connectRecur(struct node* p);
// Sets the nextRight of root and calls connectRecur()// for other nodesvoid connect(struct node* p)
{ // Set the nextRight for root
p->nextRight = NULL;
// Set the next right for rest of the nodes
// (other than root)
connectRecur(p);
}/* Set next right of all descendants of p. Assumption: p is a complete binary tree */
void connectRecur(struct node* p)
{ // Base case
if (!p)
return;
// Set the nextRight pointer for p's left child
if (p->left)
p->left->nextRight = p->right;
// Set the nextRight pointer for p's right child
// p->nextRight will be NULL if p is the right
// most child at its level
if (p->right)
p->right->nextRight
= (p->nextRight) ? p->nextRight->left : NULL;
// Set nextRight for other nodes in pre order fashion
connectRecur(p->left);
connectRecur(p->right);
}/* UTILITY FUNCTIONS *//* Helper function that allocates a new node with the given data and NULL left and right pointers. */
struct node* newnode(int data)
{ struct node* node
= (struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
node->nextRight = NULL;
return (node);
}/* Driver program to test above functions*/int main()
{ /* Constructed binary tree is
10
/ \
8 2
/
3
*/
struct node* root = newnode(10);
root->left = newnode(8);
root->right = newnode(2);
root->left->left = newnode(3);
// Populates nextRight pointer in all nodes
connect(root);
// Let us check the values of nextRight pointers
printf("Following are populated nextRight pointers in "
"the tree "
"(-1 is printed if there is no nextRight) \n");
printf("nextRight of %d is %d \n", root->data,
root->nextRight ? root->nextRight->data : -1);
printf("nextRight of %d is %d \n", root->left->data,
root->left->nextRight
? root->left->nextRight->data
: -1);
printf("nextRight of %d is %d \n", root->right->data,
root->right->nextRight
? root->right->nextRight->data
: -1);
printf("nextRight of %d is %d \n",
root->left->left->data,
root->left->left->nextRight
? root->left->left->nextRight->data
: -1);
return 0;
} |
Java
// JAVA program to connect nodes// at same level using extended// pre-order traversalimport java.util.*;
class GFG {
static class node {
int data;
node left;
node right;
node nextRight;
/*
* 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.nextRight = null;
}
};
// Sets the nextRight of
// root and calls connectRecur()
// for other nodes
static void connect(node p)
{
// Set the nextRight for root
p.nextRight = null;
// Set the next right for rest of the nodes
// (other than root)
connectRecur(p);
}
/*
* Set next right of all descendants of p. Assumption: p
* is a complete binary tree
*/
static void connectRecur(node p)
{
// Base case
if (p == null)
return;
// Set the nextRight pointer for p's left child
if (p.left != null)
p.left.nextRight = p.right;
// Set the nextRight pointer
// for p's right child p.nextRight
// will be null if p is the right
// most child at its level
if (p.right != null)
p.right.nextRight = (p.nextRight) != null
? p.nextRight.left
: null;
// Set nextRight for other
// nodes in pre order fashion
connectRecur(p.left);
connectRecur(p.right);
}
/* Driver code */
public static void main(String[] args)
{
/*
* Constructed binary tree is 10 / \ 8 2 / 3
*/
node root = new node(10);
root.left = new node(8);
root.right = new node(2);
root.left.left = new node(3);
// Populates nextRight pointer in all nodes
connect(root);
// Let us check the values
// of nextRight pointers
System.out.print(
"Following are populated nextRight pointers in the tree"
+ " (-1 is printed if there is no nextRight)\n");
System.out.print(
"nextRight of " + root.data + " is "
+ (root.nextRight != null ? root.nextRight.data
: -1)
+ "\n");
System.out.print("nextRight of " + root.left.data
+ " is "
+ (root.left.nextRight != null
? root.left.nextRight.data
: -1)
+ "\n");
System.out.print("nextRight of " + root.right.data
+ " is "
+ (root.right.nextRight != null
? root.right.nextRight.data
: -1)
+ "\n");
System.out.print(
"nextRight of " + root.left.left.data + " is "
+ (root.left.left.nextRight != null
? root.left.left.nextRight.data
: -1)
+ "\n");
}
}// This code is contributed by umadevi9616 |
Python3
# Python3 program to connect nodes at same# level using extended pre-order traversalclass newnode:
def __init__(self, data):
self.data = data
self.left = self.right = self.nextRight = None
# Sets the nextRight of root and calls# connectRecur() for other nodesdef connect(p):
# Set the nextRight for root
p.nextRight = None
# Set the next right for rest of
# the nodes (other than root)
connectRecur(p)
# Set next right of all descendants of p.# Assumption: p is a complete binary treedef connectRecur(p):
# Base case
if (not p):
return
# Set the nextRight pointer for p's
# left child
if (p.left):
p.left.nextRight = p.right
# Set the nextRight pointer for p's right
# child p.nextRight will be None if p is
# the right most child at its level
if (p.right):
if p.nextRight:
p.right.nextRight = p.nextRight.left
else:
p.right.nextRight = None
# Set nextRight for other nodes in
# pre order fashion
connectRecur(p.left)
connectRecur(p.right)
# Driver Codeif __name__ == '__main__':
# Constructed binary tree is
# 10
# / \
# 8 2
# /
# 3
root = newnode(10)
root.left = newnode(8)
root.right = newnode(2)
root.left.left = newnode(3)
# Populates nextRight pointer in all nodes
connect(root)
# Let us check the values of nextRight pointers
print("Following are populated nextRight",
"pointers in the tree (-1 is printed",
"if there is no nextRight)")
print("nextRight of", root.data, "is ", end="")
if root.nextRight:
print(root.nextRight.data)
else:
print(-1)
print("nextRight of", root.left.data, "is ", end="")
if root.left.nextRight:
print(root.left.nextRight.data)
else:
print(-1)
print("nextRight of", root.right.data, "is ", end="")
if root.right.nextRight:
print(root.right.nextRight.data)
else:
print(-1)
print("nextRight of", root.left.left.data, "is ", end="")
if root.left.left.nextRight:
print(root.left.left.nextRight.data)
else:
print(-1)
# This code is contributed by PranchalK |
C#
using System;
// C# program to connect nodes at same level using extended// pre-order traversal// A binary tree nodepublic class Node {
public int data;
public Node left, right, nextRight;
public Node(int item)
{
data = item;
left = right = nextRight = null;
}
}public class BinaryTree {
public Node root;
// Sets the nextRight of root and calls connectRecur()
// for other nodes
public virtual void connect(Node p)
{
// Set the nextRight for root
p.nextRight = null;
// Set the next right for rest of the nodes (other
// than root)
connectRecur(p);
}
/* Set next right of all descendants of p.
Assumption: p is a complete binary tree */
public virtual void connectRecur(Node p)
{
// Base case
if (p == null) {
return;
}
// Set the nextRight pointer for p's left child
if (p.left != null) {
p.left.nextRight = p.right;
}
// Set the nextRight pointer for p's right child
// p->nextRight will be NULL if p is the right most
// child at its level
if (p.right != null) {
p.right.nextRight = (p.nextRight != null)
? p.nextRight.left
: null;
}
// Set nextRight for other nodes in pre order
// fashion
connectRecur(p.left);
connectRecur(p.right);
}
// Driver program to test above functions
public static void Main(string[] args)
{
BinaryTree tree = new BinaryTree();
/* Constructed binary tree is
10
/ \
8 2
/
3
*/
tree.root = new Node(10);
tree.root.left = new Node(8);
tree.root.right = new Node(2);
tree.root.left.left = new Node(3);
// Populates nextRight pointer in all nodes
tree.connect(tree.root);
// Let us check the values of nextRight pointers
Console.WriteLine(
"Following are populated nextRight pointers in "
+ "the tree"
+ "(-1 is printed if there is no nextRight)");
int a = tree.root.nextRight != null
? tree.root.nextRight.data
: -1;
Console.WriteLine("nextRight of " + tree.root.data
+ " is " + a);
int b = tree.root.left.nextRight != null
? tree.root.left.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.left.data + " is "
+ b);
int c = tree.root.right.nextRight != null
? tree.root.right.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.right.data + " is "
+ c);
int d = tree.root.left.left.nextRight != null
? tree.root.left.left.nextRight.data
: -1;
Console.WriteLine("nextRight of "
+ tree.root.left.left.data
+ " is " + d);
}
}// This code is contributed by Shrikant13 |
Javascript
<script>// Javascript program to connect nodes// at same level using extended// pre-order traversalclass Node{ constructor(item)
{
this.data = item;
this.left = this.right = this.nextRight = null;
}
}// Sets the nextRight of// root and calls connectRecur()// for other nodesfunction connect( p) {
// Set the nextRight for root
p.nextRight = null;
// Set the next right for rest of the nodes
// (other than root)
connectRecur(p);
}
/** Set next right of all descendants of p. Assumption: p is a complete binary* tree*/function connectRecur( p) {
// Base case
if (p == null)
return;
// Set the nextRight pointer for p's left child
if (p.left != null)
p.left.nextRight = p.right;
// Set the nextRight pointer
// for p's right child p.nextRight
// will be null if p is the right
// most child at its level
if (p.right != null)
p.right.nextRight = (p.nextRight) != null ? p.nextRight.left : null;
// Set nextRight for other
// nodes in pre order fashion
connectRecur(p.left);
connectRecur(p.right);
}// Driver program to test above functions/* Constructed binary tree is 10
/ \
8 2
/
3
*/
let root = new Node(10);
root.left = new Node(8);
root.right = new Node(2);
root.left.left = new Node(3);
// Populates nextRight pointer in all nodesconnect(root);// Let us check the values of nextRight pointersdocument.write("Following are populated nextRight pointers in "
+ "the tree"
+ "(-1 is printed if there is no nextRight)<br>");
let a = root.nextRight != null ? root.nextRight.data : -1;
document.write("nextRight of " + root.data + " is "
+ a+"<br>");
let b = root.left.nextRight != null ? root.left.nextRight.data : -1;
document.write("nextRight of " + root.left.data + " is "
+ b+"<br>");
let c = root.right.nextRight != null ? root.right.nextRight.data : -1;
document.write("nextRight of " + root.right.data + " is "
+ c+"<br>");
let d = root.left.left.nextRight != null ? root.left.left.nextRight.data : -1;
document.write("nextRight of " + root.left.left.data + " is "
+ d+"<br>");
// This code is contributed by jana_sayantan. </script> |
Output
Following are populated nextRight pointers in the tree (-1 is printed if there is no nextRight) nextRight of 10 is -1 nextRight of 8 is 2 nextRight of 2 is -1 nextRight of 3 is -1
Thanks to Dhanya for suggesting this approach.
Time Complexity: O(N)
Auxiliary Space: O(N)
Why doesn’t method 2 work for trees which are not Complete Binary Trees?
Let us consider following tree as an example. In Method 2, we set the nextRight pointer in pre order fashion. When we are at node 4, we set the nextRight of its children which are 8 and 9 (the nextRight of 4 is already set as node 5). nextRight of 8 will simply be set as 9, but nextRight of 9 will be set as NULL which is incorrect. We can’t set the correct nextRight, because when we set nextRight of 9, we only have nextRight of node 4 and ancestors of node 4, we don’t have nextRight of nodes in right subtree of root.
1
/ \
2 3
/ \ / \
4 5 6 7
/ \ / \
8 9 10 11See Connect nodes at same level using constant extra space for more solutions.