# Connect Nodes at same Level (Level Order Traversal)

Write a function to connect all the adjacent nodes at the same level in a binary tree.

Example:

```Input Tree
A
/ \
B   C
/ \   \
D   E   F

Output Tree
A--->NULL
/ \
B-->C-->NULL
/ \   \
D-->E-->F-->NULL
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We have already discussed O(n^2) time and O approach in Connect nodes at same level as morris traversal in worst case can be O(n) and calling it to set right pointer can result in O(n^2) time complexity.

In this post, We have discussed Level Order Traversal with NULL markers which are needed to mark levels in tree.

 `// Connect nodes at same level using level order ` `// traversal. ` `#include ` `using` `namespace` `std; ` ` `  `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* left, *right, *nextRight; ` `}; ` ` `  `// Sets nextRight of all nodes of a tree ` `void` `connect(``struct` `Node* root) ` `{ ` `    ``queue q; ` `    ``q.push(root); ` ` `  `    ``// null marker to represent end of current level ` `    ``q.push(NULL);  ` ` `  `    ``// Do Level order of tree using NULL markers ` `    ``while` `(!q.empty()) { ` `        ``Node *p = q.front(); ` `        ``q.pop(); ` `        ``if` `(p != NULL) { ` ` `  `            ``// next element in queue represents next  ` `            ``// node at current Level  ` `            ``p->nextRight = q.front(); ` ` `  `            ``// push left and right children of current ` `            ``// node ` `            ``if` `(p->left) ` `                ``q.push(p->left);  ` `            ``if` `(p->right) ` `                ``q.push(p->right); ` `        ``}  ` `        `  `        ``// if queue is not empty, push NULL to mark  ` `        ``// nodes at this level are visited ` `        ``else` `if` `(!q.empty())  ` `            ``q.push(NULL);  ` `    ``} ` `} ` ` `  `/* 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 = node->right = node->nextRight = NULL; ` `    ``return` `(node); ` `} ` ` `  `/* Driver program to test above functions*/` `int` `main() ` `{ ` ` `  `    ``/* Constructed binary tree is ` `              ``10 ` `            ``/   \ ` `          ``8      2 ` `        ``/         \ ` `      ``3            90 ` `    ``*/` `    ``struct` `Node* root = newnode(10); ` `    ``root->left = newnode(8); ` `    ``root->right = newnode(2); ` `    ``root->left->left = newnode(3); ` `    ``root->right->right = newnode(90); ` ` `  `    ``// Populates nextRight pointer in all nodes ` `    ``connect(root); ` ` `  `    ``// Let us check the values of nextRight pointers ` `    ``printf``(``"Following are populated nextRight pointers in \n"` `     ``"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); ` `    ``printf``(``"nextRight of %d is %d \n"``, root->right->right->data, ` `     ``root->right->right->nextRight ? root->right->right->nextRight->data : -1); ` `    ``return` `0; ` `} `

 `// Connect nodes at same level using level order ` `// traversal. ` `import` `java.util.LinkedList; ` `import` `java.util.Queue; ` `public` `class` `Connect_node_same_level { ` `     `  `    ``// Node class ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node left, right, nextRight; ` `        ``Node(``int` `data){ ` `            ``this``.data = data; ` `            ``left = ``null``; ` `            ``right = ``null``; ` `            ``nextRight = ``null``; ` `        ``} ` `    ``}; ` `      `  `    ``// Sets nextRight of all nodes of a tree ` `    ``static` `void` `connect(Node root) ` `    ``{ ` `        ``Queue q = ``new` `LinkedList();  ` `        ``q.add(root); ` `      `  `        ``// null marker to represent end of current level ` `        ``q.add(``null``);  ` `      `  `        ``// Do Level order of tree using NULL markers ` `        ``while` `(!q.isEmpty()) { ` `            ``Node p = q.peek(); ` `            ``q.remove(); ` `            ``if` `(p != ``null``) { ` `      `  `                ``// next element in queue represents next  ` `                ``// node at current Level  ` `                ``p.nextRight = q.peek(); ` `      `  `                ``// push left and right children of current ` `                ``// node ` `                ``if` `(p.left != ``null``) ` `                    ``q.add(p.left);  ` `                ``if` `(p.right != ``null``) ` `                    ``q.add(p.right); ` `            ``}  ` `             `  `            ``// if queue is not empty, push NULL to mark  ` `            ``// nodes at this level are visited ` `            ``else` `if` `(!q.isEmpty())  ` `                ``q.add(``null``);  ` `        ``} ` `    ``} ` `      `  `    ``/* Driver program to test above functions*/` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `      `  `        ``/* Constructed binary tree is ` `                  ``10 ` `                ``/   \ ` `              ``8      2 ` `            ``/         \ ` `          ``3            90 ` `        ``*/` `        ``Node root = ``new` `Node(``10``); ` `        ``root.left = ``new` `Node(``8``); ` `        ``root.right = ``new` `Node(``2``); ` `        ``root.left.left = ``new` `Node(``3``); ` `        ``root.right.right = ``new` `Node(``90``); ` `      `  `        ``// Populates nextRight pointer in all nodes ` `        ``connect(root); ` `      `  `        ``// Let us check the values of nextRight pointers ` `        ``System.out.println(``"Following are populated nextRight pointers in \n"` `+ ` `      ``"the tree (-1 is printed if there is no nextRight)"``); ` `        ``System.out.println(``"nextRight of "``+ root.data +``" is "``+ ` `        ``((root.nextRight != ``null``) ? root.nextRight.data : -``1``)); ` `        ``System.out.println(``"nextRight of "``+ root.left.data+``" is "``+ ` `        ``((root.left.nextRight != ``null``) ? root.left.nextRight.data : -``1``)); ` `        ``System.out.println(``"nextRight of "``+ root.right.data+``" is "``+ ` `        ``((root.right.nextRight != ``null``) ? root.right.nextRight.data : -``1``)); ` `        ``System.out.println(``"nextRight of "``+  root.left.left.data+``" is "``+ ` `        ``((root.left.left.nextRight != ``null``) ? root.left.left.nextRight.data : -``1``)); ` `        ``System.out.println(``"nextRight of "``+  root.right.right.data+``" is "``+ ` `        ``((root.right.right.nextRight != ``null``) ? root.right.right.nextRight.data : -``1``)); ` `    ``} ` `}     ` `// This code is contributed by Sumit Ghosh `

 `#! /usr/bin/env python3 ` ` `  `# connect nodes at same level using level order traversal ` `import` `sys ` ` `  ` `  `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        ``self``.nextRight ``=` `None` ` `  `    ``def` `__str__(``self``): ` `        ``return` `'{}'``.``format``(``self``.data) ` ` `  ` `  `def` `printLevelByLevel(root): ` `    ``# print level by level ` `    ``if` `root: ` `        ``node ``=` `root ` `        ``while` `node: ` `            ``print``(``'{}'``.``format``(node.data), end``=``' '``) ` `            ``node ``=` `node.nextRight ` `        ``print``() ` `        ``if` `root.left: ` `            ``printLevelByLevel(root.left) ` `        ``else``: ` `            ``printLevelByLevel(root.right) ` ` `  ` `  `def` `inorder(root): ` `    ``if` `root: ` `        ``inorder(root.left) ` `        ``print``(root.data, end``=``' '``) ` `        ``inorder(root.right) ` ` `  ` `  `def` `connect(root): ` `    ``# set nextRight of all nodes of a tree ` `    ``queue ``=` `[] ` `    ``queue.append(root) ` `    ``# null marker to represent end of current level ` `    ``queue.append(``None``) ` `    ``# do level order of tree using None markers ` `    ``while` `queue: ` `        ``p ``=` `queue.pop(``0``) ` `        ``if` `p: ` `            ``# next element in queue represents ` `            ``# next node at current level ` `            ``p.nextRight ``=` `queue[``0``] ` `            ``# pus left and right children of current node ` `            ``if` `p.left: ` `                ``queue.append(p.left) ` `            ``if` `p.right: ` `                ``queue.append(p.right) ` `        ``elif` `queue: ` `            ``queue.append(``None``) ` ` `  ` `  `def` `main(): ` `    ``"""Driver program to test above functions. ` `        ``Constructed binary tree is ` `                ``10 ` `               ``/  \ ` `             ``8      2 ` `            ``/        \ ` `          ``3            90 ` `    ``"""` ` `  `    ``root ``=` `Node(``10``) ` `    ``root.left ``=` `Node(``8``) ` `    ``root.right ``=` `Node(``2``) ` `    ``root.left.left ``=` `Node(``3``) ` `    ``root.right.right ``=` `Node(``90``) ` ` `  `    ``# Populates nextRight pointer in all nodes ` `    ``connect(root) ` ` `  `    ``# Let us check the values of nextRight pointers ` `    ``print``(``"Following are populated nextRight pointers in \n"` `    ``"the tree (-1 is printed if there is no nextRight) \n"``) ` `    ``if``(root.nextRight !``=` `None``): ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.data,root.nextRight.data)) ` `    ``else``: ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.data,``-``1``)) ` `    ``if``(root.left.nextRight !``=` `None``): ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.left.data,root.left.nextRight.data)) ` `    ``else``: ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.left.data,``-``1``)) ` `    ``if``(root.right.nextRight !``=` `None``): ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.right.data,root.right.nextRight.data)) ` `    ``else``: ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.right.data,``-``1``)) ` `    ``if``(root.left.left.nextRight !``=` `None``): ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.left.left.data,root.left.left.nextRight.data)) ` `    ``else``: ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.left.left.data,``-``1``)) ` `    ``if``(root.right.right.nextRight !``=` `None``): ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.right.right.data,root.right.right.nextRight.data)) ` `    ``else``: ` `        ``print``(``"nextRight of %d is %d \n"` `%``(root.right.right.data,``-``1``)) ` `         `  `    ``print``() ` ` `  ` `  `if` `__name__ ``=``=` `"__main__"``: ` `    ``main() ` ` `  `# This code is contributed by Ram Basnet `

 `// Connect nodes at same level using level order  ` `// traversal.  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `Connect_node_same_level  ` `{  ` `     `  `    ``// Node class  ` `    ``class` `Node ` `    ``{  ` `        ``public` `int` `data;  ` `        ``public` `Node left, right, nextRight;  ` `        ``public` `Node(``int` `data) ` `        ``{  ` `            ``this``.data = data;  ` `            ``left = ``null``;  ` `            ``right = ``null``;  ` `            ``nextRight = ``null``;  ` `        ``}  ` `    ``};  ` `     `  `    ``// Sets nextRight of all nodes of a tree  ` `    ``static` `void` `connect(Node root)  ` `    ``{  ` `        ``Queue q = ``new` `Queue();  ` `        ``q.Enqueue(root);  ` `     `  `        ``// null marker to represent end of current level  ` `        ``q.Enqueue(``null``);  ` `     `  `        ``// Do Level order of tree using NULL markers  ` `        ``while` `(q.Count!=0) ` `        ``{  ` `            ``Node p = q.Peek();  ` `            ``q.Dequeue();  ` `            ``if` `(p != ``null``) ` `            ``{  ` `     `  `                ``// next element in queue represents next  ` `                ``// node at current Level  ` `                ``p.nextRight = q.Peek();  ` `     `  `                ``// push left and right children of current  ` `                ``// node  ` `                ``if` `(p.left != ``null``)  ` `                    ``q.Enqueue(p.left);  ` `                ``if` `(p.right != ``null``)  ` `                    ``q.Enqueue(p.right);  ` `            ``}  ` `             `  `            ``// if queue is not empty, push NULL to mark  ` `            ``// nodes at this level are visited  ` `            ``else` `if` `(q.Count!=0)  ` `                ``q.Enqueue(``null``);  ` `        ``}  ` `    ``}  ` `     `  `    ``/* Driver code*/` `    ``public` `static` `void` `Main()  ` `    ``{  ` `     `  `        ``/* Constructed binary tree is  ` `                ``10  ` `                ``/ \  ` `            ``8 2  ` `            ``/     \  ` `        ``3     90  ` `        ``*/` `        ``Node root = ``new` `Node(10);  ` `        ``root.left = ``new` `Node(8);  ` `        ``root.right = ``new` `Node(2);  ` `        ``root.left.left = ``new` `Node(3);  ` `        ``root.right.right = ``new` `Node(90);  ` `     `  `        ``// Populates nextRight pointer in all nodes  ` `        ``connect(root);  ` `     `  `        ``// Let us check the values of nextRight pointers  ` `        ``Console.WriteLine(``"Following are populated nextRight pointers in \n"` `+  ` `    ``"the tree (-1 is printed if there is no nextRight)"``);  ` `        ``Console.WriteLine(``"nextRight of "``+ root.data +``" is "``+  ` `        ``((root.nextRight != ``null``) ? root.nextRight.data : -1));  ` `        ``Console.WriteLine(``"nextRight of "``+ root.left.data+``" is "``+  ` `        ``((root.left.nextRight != ``null``) ? root.left.nextRight.data : -1));  ` `        ``Console.WriteLine(``"nextRight of "``+ root.right.data+``" is "``+  ` `        ``((root.right.nextRight != ``null``) ? root.right.nextRight.data : -1));  ` `        ``Console.WriteLine(``"nextRight of "``+ root.left.left.data+``" is "``+  ` `        ``((root.left.left.nextRight != ``null``) ? root.left.left.nextRight.data : -1));  ` `        ``Console.WriteLine(``"nextRight of "``+ root.right.right.data+``" is "``+  ` `        ``((root.right.right.nextRight != ``null``) ? root.right.right.nextRight.data : -1));  ` `    ``}  ` `}  ` ` `  `/* This code is contributed by Rajput-Ji*/`

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 90
nextRight of 90 is -1
```

Time complexity :O(n) where n is the number of nodes

Alternate Implementation:
We can also follow the implementation discussed in Print level order traversal line by line | Set 1. We keep connecting nodes of same level by keeping track of prev visited node of same level.
Implementation : https://ide.geeksforgeeks.org/gV1Oc2

Thanks to Akilan Sengottaiyan for suggesting this alternate implementation.

This article is contributed by Abhishek Rajput. 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.