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


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find Levelorder
// successor of given node in the
// Binary Tree
  
#include <bits/stdc++.h>
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<Node*> 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Node> q = new LinkedList<Node> (); 
  
    // 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"); 
  
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Node> q = new LinkedList<Node> (); 
  
    // 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

chevron_right


Output:

LevelOrder successor of 24 is 27


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

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.