# Level Order Successor of a node in Binary Tree

Given a binary tree and a node in the binary tree, find Levelorder successor of the given node. That is, the node that appears after the given node in the level order traversal of the tree.

Note: The task is not just to print the data of the node, you have to return the complete node from the tree.

Examples:

```Consider the following binary tree
20
/      \
10       26
/  \     /   \
4     18  24    27
/  \
14   19
/  \
13  15

Levelorder traversal of given tree is:
20, 10, 26, 4, 18, 24, 27, 14, 19, 13, 15

Input : 24
Output : 27

Input : 4
Output : 18
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Check if the root is NULL, that is tree is empty. If true then return NULL.
2. Check if the given node is root. If true:
• Check if left child of root exists, if true return left child of root.
• Else, check if right child exists, return it.
• If the root is the only node. Return NULL.
3. Otherwise, perform Level Order Traversal on the tree using a Queue.
4. At every step of the level order traversal, check if the current node matches with the given node.
5. If True, stop traversing any further and return the element at top of queue which will be the next node in the level order traversal.

Below is the implementation of the above approach:

## C++

 `// CPP program to find Levelorder ` `// successor of given node in the ` `// Binary Tree ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Tree Node ` `struct` `Node { ` `    ``struct` `Node *left, *right; ` `    ``int` `value; ` `}; ` ` `  `// Utility function to create a ` `// new node with given value ` `struct` `Node* newNode(``int` `value) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->left = temp->right = NULL; ` `    ``temp->value = value; ` ` `  `    ``return` `temp; ` `} ` ` `  `// Function to find the Level Order Successor ` `// of a given Node in Binary Tree ` `Node* levelOrderSuccessor(Node* root, Node* key) ` `{ ` `    ``// Base Case ` `    ``if` `(root == NULL) ` `        ``return` `NULL; ` ` `  `    ``// If root equals to key ` `    ``if` `(root == key) { ` ` `  `        ``// If left child exists it will be ` `        ``// the Postorder Successor ` `        ``if` `(root->left) ` `            ``return` `root->left; ` ` `  `        ``// Else if right child exists it will be ` `        ``// the Postorder Successor ` `        ``else` `if` `(root->right) ` `            ``return` `root->right; ` `        ``else` `            ``return` `NULL; ``// No Successor ` `    ``} ` ` `  `    ``// Create an empty queue for level ` `    ``// order traversal ` `    ``queue q; ` ` `  `    ``// Enqueue Root ` `    ``q.push(root); ` ` `  `    ``while` `(!q.empty()) { ` `        ``Node* nd = q.front(); ` `        ``q.pop(); ` ` `  `        ``if` `(nd->left != NULL) { ` `            ``q.push(nd->left); ` `        ``} ` ` `  `        ``if` `(nd->right != NULL) { ` `            ``q.push(nd->right); ` `        ``} ` ` `  `        ``if` `(nd == key) ` `            ``break``; ` `    ``} ` ` `  `    ``return` `q.front(); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``struct` `Node* root = newNode(20); ` `    ``root->left = newNode(10); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(18); ` `    ``root->right = newNode(26); ` `    ``root->right->left = newNode(24); ` `    ``root->right->right = newNode(27); ` `    ``root->left->right->left = newNode(14); ` `    ``root->left->right->left->left = newNode(13); ` `    ``root->left->right->left->right = newNode(15); ` `    ``root->left->right->right = newNode(19); ` ` `  `    ``struct` `Node* key = root->right->left; ``// node 24 ` ` `  `    ``struct` `Node* res = levelOrderSuccessor(root, key); ` ` `  `    ``if` `(res) ` `        ``cout << ``"LevelOrder successor of "` `             ``<< key->value << ``" is "` `<< res->value; ` `    ``else` `        ``cout << ``"LevelOrder successor of "` `             ``<< key->value << ``" is "`  `<< ``"NULL"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find Levelorder  ` `// successor of given node in the  ` `// Binary Tree  ` `import` `java.util.*; ` `class` `GfG { ` ` `  `// Tree Node  ` `static` `class` `Node {  ` `    ``Node left, right;  ` `    ``int` `value;  ` `} ` ` `  `// Utility function to create a  ` `// new node with given value  ` `static` `Node newNode(``int` `value)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.left = ``null``; ` `    ``temp.right = ``null``;  ` `    ``temp.value = value;  ` ` `  `    ``return` `temp;  ` `}  ` ` `  `// Function to find the Level Order Successor  ` `// of a given Node in Binary Tree  ` `static` `Node levelOrderSuccessor(Node root, Node key)  ` `{  ` `    ``// Base Case  ` `    ``if` `(root == ``null``)  ` `        ``return` `null``;  ` ` `  `    ``// If root equals to key  ` `    ``if` `(root == key) {  ` ` `  `        ``// If left child exists it will be  ` `        ``// the Postorder Successor  ` `        ``if` `(root.left != ``null``)  ` `            ``return` `root.left;  ` ` `  `        ``// Else if right child exists it will be  ` `        ``// the Postorder Successor  ` `        ``else` `if` `(root.right != ``null``)  ` `            ``return` `root.right;  ` `        ``else` `            ``return` `null``; ``// No Successor  ` `    ``}  ` ` `  `    ``// Create an empty queue for level  ` `    ``// order traversal  ` `    ``Queue q = ``new` `LinkedList ();  ` ` `  `    ``// Enqueue Root  ` `    ``q.add(root);  ` ` `  `    ``while` `(!q.isEmpty()) {  ` `        ``Node nd = q.peek();  ` `        ``q.remove();  ` ` `  `        ``if` `(nd.left != ``null``) {  ` `            ``q.add(nd.left);  ` `        ``}  ` ` `  `        ``if` `(nd.right != ``null``) {  ` `            ``q.add(nd.right);  ` `        ``}  ` ` `  `        ``if` `(nd == key)  ` `            ``break``;  ` `    ``}  ` ` `  `    ``return` `q.peek();  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``Node root = newNode(``20``);  ` `    ``root.left = newNode(``10``);  ` `    ``root.left.left = newNode(``4``);  ` `    ``root.left.right = newNode(``18``);  ` `    ``root.right = newNode(``26``);  ` `    ``root.right.left = newNode(``24``);  ` `    ``root.right.right = newNode(``27``);  ` `    ``root.left.right.left = newNode(``14``);  ` `    ``root.left.right.left.left = newNode(``13``);  ` `    ``root.left.right.left.right = newNode(``15``);  ` `    ``root.left.right.right = newNode(``19``);  ` ` `  `    ``Node key = root.right.left; ``// node 24  ` ` `  `Node res = levelOrderSuccessor(root, key);  ` ` `  `    ``if` `(res != ``null``)  ` `        ``System.out.println(``"LevelOrder successor of "`  `                        ``+key.value + ``" is "` `+ res.value);  ` `    ``else` `        ``System.out.println(``"LevelOrder successor of "`  `                            ``+key.value + ``" is NULL"``);  ` ` `  `} ` `}  `

## Python 3

 `# Python3 program to find Level  ` `# order successor of given node ` `# in the Binary Tree  ` ` `  `# Node defintion  ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, value): ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        ``self``.value ``=` `value ` ` `  `# Function to find the Level  ` `# Order Successor of a given ` `# Node in Binary Tree ` `def` `levelOrderSuccessor(root, key): ` `     `  `    ``# Base Case ` `    ``if` `root ``=``=` `None``: ` `        ``return` `None` `     `  `    ``# If root equals to key ` `    ``elif` `root ``=``=` `key: ` `         `  `        ``# If left child exists, it will ` `        ``# be the PostOrder Successor ` `        ``if` `root.left: ` `            ``return` `root.left ` `             `  `        ``# Else if right child exists, it  ` `        ``# will be the PostOrder Successor ` `        ``elif` `root.right: ` `            ``return` `root.right ` `         `  `        ``# No Successor ` `        ``else``: ` `            ``return` `None` `             `  `    ``# Create an empty queue for  ` `    ``# level order traversal  ` `    ``q ``=` `[]  ` ` `  `    ``# Enqueue Root  ` `    ``q.append(root)  ` ` `  `    ``while` `len``(q) !``=` `0``:  ` `        ``nd ``=` `q.pop(``0``)  ` ` `  `        ``if` `nd.left !``=` `None``:  ` `            ``q.append(nd.left) ` ` `  `        ``if` `nd.right !``=` `None``:  ` `            ``q.append(nd.right) ` `     `  `        ``if` `nd ``=``=` `key:  ` `            ``break` ` `  `    ``return` `q[``0``] ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``root ``=` `Node(``20``) ` `    ``root.left ``=` `Node(``10``) ` `    ``root.left.left ``=` `Node(``4``)  ` `    ``root.left.right ``=` `Node(``18``)  ` `    ``root.right ``=` `Node(``26``) ` `    ``root.right.left ``=` `Node(``24``)  ` `    ``root.right.right ``=` `Node(``27``)  ` `    ``root.left.right.left ``=` `Node(``14``)  ` `    ``root.left.right.left.left ``=` `Node(``13``)  ` `    ``root.left.right.left.right ``=` `Node(``15``) ` `    ``root.left.right.right ``=` `Node(``19``) ` ` `  `    ``key ``=` `root.right.left ``# node 24  ` ` `  `    ``res ``=` `levelOrderSuccessor(root, key)  ` ` `  `    ``if` `res:  ` `        ``print``(``"LevelOrder successor of "` `+`  `                 ``str``(key.value) ``+` `" is "` `+`  `                 ``str``(res.value))  ` `     `  `    ``else``: ` `        ``print``(``"LevelOrder successor of "` `+` `              ``str``(key.value) ``+` `" is NULL"``)  ` ` `  `# This code is contributed  ` `# by Rituraj Jain `

## C#

 `// C# program to find Levelorder  ` `// successor of given node in the  ` `// Binary Tree  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GfG  ` `{ ` ` `  `// Tree Node  ` `public` `class` `Node ` `{  ` `    ``public` `Node left, right;  ` `    ``public` `int` `value;  ` `} ` ` `  `// Utility function to create a  ` `// new node with given value  ` `static` `Node newNode(``int` `value)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.left = ``null``; ` `    ``temp.right = ``null``;  ` `    ``temp.value = value;  ` ` `  `    ``return` `temp;  ` `}  ` ` `  `// Function to find the Level Order Successor  ` `// of a given Node in Binary Tree  ` `static` `Node levelOrderSuccessor(Node root, Node key)  ` `{  ` `    ``// Base Case  ` `    ``if` `(root == ``null``)  ` `        ``return` `null``;  ` ` `  `    ``// If root equals to key  ` `    ``if` `(root == key)  ` `    ``{  ` ` `  `        ``// If left child exists it will be  ` `        ``// the Postorder Successor  ` `        ``if` `(root.left != ``null``)  ` `            ``return` `root.left;  ` ` `  `        ``// Else if right child exists it will be  ` `        ``// the Postorder Successor  ` `        ``else` `if` `(root.right != ``null``)  ` `            ``return` `root.right;  ` `        ``else` `            ``return` `null``; ``// No Successor  ` `    ``}  ` ` `  `    ``// Create an empty queue for level  ` `    ``// order traversal  ` `    ``LinkedList q = ``new` `LinkedList ();  ` ` `  `    ``// Enqueue Root  ` `    ``q.AddLast(root);  ` ` `  `    ``while` `(q.Count != 0)  ` `    ``{  ` `        ``Node nd = q.First.Value;  ` `        ``q.RemoveFirst();  ` ` `  `        ``if` `(nd.left != ``null``) ` `        ``{  ` `            ``q.AddLast(nd.left);  ` `        ``}  ` ` `  `        ``if` `(nd.right != ``null``)  ` `        ``{  ` `            ``q.AddLast(nd.right);  ` `        ``}  ` ` `  `        ``if` `(nd == key)  ` `            ``break``;  ` `    ``}  ` ` `  `    ``return` `q.First.Value;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `    ``Node root = newNode(20);  ` `    ``root.left = newNode(10);  ` `    ``root.left.left = newNode(4);  ` `    ``root.left.right = newNode(18);  ` `    ``root.right = newNode(26);  ` `    ``root.right.left = newNode(24);  ` `    ``root.right.right = newNode(27);  ` `    ``root.left.right.left = newNode(14);  ` `    ``root.left.right.left.left = newNode(13);  ` `    ``root.left.right.left.right = newNode(15);  ` `    ``root.left.right.right = newNode(19);  ` ` `  `    ``Node key = root.right.left; ``// node 24  ` ` `  `    ``Node res = levelOrderSuccessor(root, key);  ` ` `  `    ``if` `(res != ``null``)  ` `        ``Console.WriteLine(``"LevelOrder successor of "` `                        ``+key.value + ``" is "` `+ res.value);  ` `    ``else` `        ``Console.WriteLine(``"LevelOrder successor of "` `                            ``+key.value + ``" is NULL"``);  ` ` `  `} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

```LevelOrder successor of 24 is 27
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

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.

Article Tags :
Practice Tags :

1

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