# Connect nodes at same level

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   6

Output:

1—>NULL
/  \
2–>3–>NULL
/   \      \
4–>5–>6–>NULL

Input:

10
/  \
12   15
/ \    \
5   4   3

Output:

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.

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 ` `#include ` `using` `namespace` `std;`   `// A Binary Tree Node` `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;` `    ``}` `};` `// 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 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 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 tree` `class` `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 ----------------> NULL`     `def` `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 Code` `if` `__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 level` `using` `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 q = ``new` `Queue();`   `        ``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

 ``

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 ` `#include ` `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 nodes` `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 */` `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 ` `#include `   `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 nodes` `void` `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 traversal` `import` `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 traversal`     `class` `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 nodes`     `def` `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 tree`     `def` `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 Code` `if` `__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 node` `public` `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

 ``

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   11```

See Connect nodes at same level using constant extra space for more solutions.