Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find next right node of a given key

  • Difficulty Level : Easy
  • Last Updated : 16 Mar, 2022

Given a Binary tree and a key in the binary tree, find the node right to the given key. If there is no node on right side, then return NULL. Expected time complexity is O(n) where n is the number of nodes in the given binary tree.

For example, consider the following Binary Tree. Output for 2 is 6, output for 4 is 5. Output for 10, 6 and 5 is NULL. 

                  10
               /      \
          2         6
           /   \         \ 
     8      4          5

Solution: The idea is to do level order traversal of given Binary Tree. When we find the given key, we just check if the next node in level order traversal is of same level, if yes, we return the next node, otherwise return NULL. 

C++




/* Program to find next right of a given key */
#include <iostream>
#include <queue>
using namespace std;
 
// A Binary Tree Node
struct node
{
    struct node *left, *right;
    int key;
};
 
// Method to find next right of given key k, it returns NULL if k is
// not present in tree or k is the rightmost node of its level
node* nextRight(node *root, int k)
{
    // Base Case
    if (root == NULL)
        return 0;
 
    // Create an empty queue for level order traversal
    queue<node *> qn; // A queue to store node addresses
    queue<int> ql;   // Another queue to store node levels
 
    int level = 0;  // Initialize level as 0
 
    // Enqueue Root and its level
    qn.push(root);
    ql.push(level);
 
    // A standard BFS loop
    while (qn.size())
    {
        // dequeue an node from qn and its level from ql
        node *node = qn.front();
        level = ql.front();
        qn.pop();
        ql.pop();
 
        // If the dequeued node has the given key k
        if (node->key == k)
        {
            // If there are no more items in queue or given node is
            // the rightmost node of its level, then return NULL
            if (ql.size() == 0 || ql.front() != level)
               return NULL;
 
            // Otherwise return next node from queue of nodes
            return qn.front();
        }
 
        // Standard BFS steps: enqueue children of this node
        if (node->left != NULL)
        {
            qn.push(node->left);
            ql.push(level+1);
        }
        if (node->right != NULL)
        {
            qn.push(node->right);
            ql.push(level+1);
        }
    }
 
    // We reach here if given key x doesn't exist in tree
    return NULL;
}
 
// Utility function to create a new tree node
node* newNode(int key)
{
    node *temp = new node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return temp;
}
 
// A utility function to test above functions
void test(node *root, int k)
{
    node *nr = nextRight(root, k);
    if (nr != NULL)
      cout << "Next Right of " << k << " is " << nr->key << endl;
    else
      cout << "No next right node found for " << k << endl;
}
 
// Driver program to test above functions
int main()
{
    // Let us create binary tree given in the above example
    node *root = newNode(10);
    root->left = newNode(2);
    root->right = newNode(6);
    root->right->right = newNode(5);
    root->left->left = newNode(8);
    root->left->right = newNode(4);
 
    test(root, 10);
    test(root, 2);
    test(root, 6);
    test(root, 5);
    test(root, 8);
    test(root, 4);
    return 0;
}
Java



// Java program to find next right of a given key
  
import java.util.LinkedList;
import java.util.Queue;
  
// A binary tree node
class Node
{
    int data;
    Node left, right;
  
    Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
class BinaryTree
{
    Node root;
  
    // Method to find next right of given key k, it returns NULL if k is
    // not present in tree or k is the rightmost node of its level
    Node nextRight(Node first, int k)
    {
        // Base Case
        if (first == null)
            return null;
  
        // Create an empty queue for level order traversal
        // A queue to store node addresses
        Queue<Node> qn = new LinkedList<Node>();
         
        // Another queue to store node levels
        Queue<Integer> ql = new LinkedList<Integer>();  
  
        int level = 0;  // Initialize level as 0
  
        // Enqueue Root and its level
        qn.add(first);
        ql.add(level);
  
        // A standard BFS loop
        while (qn.size() != 0)
        {
            // dequeue an node from qn and its level from ql
            Node node = qn.peek();
            level = ql.peek();
            qn.remove();
            ql.remove();
  
            // If the dequeued node has the given key k
            if (node.data == k)
            {
                // If there are no more items in queue or given node is
                // the rightmost node of its level, then return NULL
                if (ql.size() == 0 || ql.peek() != level)
                    return null;
  
                // Otherwise return next node from queue of nodes
                return qn.peek();
            }
  
            // Standard BFS steps: enqueue children of this node
            if (node.left != null)
            {
                qn.add(node.left);
                ql.add(level + 1);
            }
            if (node.right != null)
            {
                qn.add(node.right);
                ql.add(level + 1);
            }
        }
  
        // We reach here if given key x doesn't exist in tree
        return null;
    }
  
    // A utility function to test above functions
    void test(Node node, int k)
    {
        Node nr = nextRight(root, k);
        if (nr != null)
            System.out.println("Next Right of " + k + " is " + nr.data);
        else
            System.out.println("No next right node found for " + k);
    }
  
    // Driver program to test above functions
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(10);
        tree.root.left = new Node(2);
        tree.root.right = new Node(6);
        tree.root.right.right = new Node(5);
        tree.root.left.left = new Node(8);
        tree.root.left.right = new Node(4);
  
        tree.test(tree.root, 10);
        tree.test(tree.root, 2);
        tree.test(tree.root, 6);
        tree.test(tree.root, 5);
        tree.test(tree.root, 8);
        tree.test(tree.root, 4);
  
    }
}
  
// This code has been contributed by Mayank Jaiswal
Python3



# Python program to find next right node of given key
 
# A Binary Tree Node
class Node:
     
    # Constructor to create a new node
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None
     
# Method to find next right of a given key k, it returns
# None if k is not present in tree or k is the rightmost
# node of its level
def nextRight(root, k):
 
    # Base Case
    if root is None:
        return 0
 
    # Create an empty queue for level order traversal
    qn =  [] # A queue to store node addresses
    q1 = [] # Another queue to store node levels
 
    level = 0
 
    # Enqueue root and its level
    qn.append(root)
    q1.append(level)
 
    # Standard BFS loop
    while(len(qn) > 0):
 
        # Dequeue an node from qn and its level from q1
        node = qn.pop(0)
        level = q1.pop(0)
 
        # If the dequeued node has the given key k
        if node.key == k :
 
            # If there are no more items in queue or given
            # node is the rightmost node of its level,
            # then return None
            if (len(q1) == 0 or q1[0] != level):
                return None
 
            # Otherwise return next node from queue of nodes
            return qn[0]
 
        # Standard BFS steps: enqueue children of this node
        if node.left is not None:
            qn.append(node.left)
            q1.append(level+1)
 
        if node.right is not None:
            qn.append(node.right)
            q1.append(level+1)
 
    # We reach here if given key x doesn't exist in tree
    return None
 
def test(root, k):
    nr = nextRight(root, k)
    if nr is not None:
        print ("Next Right of " + str(k) + " is " + str(nr.key))
    else:
        print ("No next right node found for " + str(k))
 
# Driver program to test above function
root = Node(10)
root.left = Node(2)
root.right = Node(6)
root.right.right = Node(5)
root.left.left = Node(8)
root.left.right = Node(4)
 
test(root, 10)
test(root, 2)
test(root, 6)
test(root, 5)
test(root, 8)
test(root, 4)
 
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
C#



// C# program to find next right of a given key
using System;
using System.Collections.Generic;
 
// A binary tree node
public class Node
{
    public int data;
    public Node left, right;
 
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
 
public class BinaryTree
{
    Node root;
 
    // Method to find next right of given
    // key k, it returns NULL if k is
    // not present in tree or k is the
    // rightmost node of its level
    Node nextRight(Node first, int k)
    {
        // Base Case
        if (first == null)
            return null;
 
        // Create an empty queue for
        // level order traversal
        // A queue to store node addresses
        Queue<Node> qn = new Queue<Node>();
         
        // Another queue to store node levels
        Queue<int> ql = new Queue<int>();
 
        int level = 0; // Initialize level as 0
 
        // Enqueue Root and its level
        qn.Enqueue(first);
        ql.Enqueue(level);
 
        // A standard BFS loop
        while (qn.Count != 0)
        {
            // dequeue an node from
            // qn and its level from ql
            Node node = qn.Peek();
            level = ql.Peek();
            qn.Dequeue();
            ql.Dequeue();
 
            // If the dequeued node has the given key k
            if (node.data == k)
            {
                // If there are no more items
                // in queue or given node is
                // the rightmost node of its
                // level, then return NULL
                if (ql.Count == 0 || ql.Peek() != level)
                    return null;
 
                // Otherwise return next
                // node from queue of nodes
                return qn.Peek();
            }
 
            // Standard BFS steps: enqueue
            // children of this node
            if (node.left != null)
            {
                qn.Enqueue(node.left);
                ql.Enqueue(level + 1);
            }
            if (node.right != null)
            {
                qn.Enqueue(node.right);
                ql.Enqueue(level + 1);
            }
        }
 
        // We reach here if given
        // key x doesn't exist in tree
        return null;
    }
 
    // A utility function to test above functions
    void test(Node node, int k)
    {
        Node nr = nextRight(root, k);
        if (nr != null)
            Console.WriteLine("Next Right of " +
                        k + " is " + nr.data);
        else
            Console.WriteLine("No next right node found for " + k);
    }
 
    // Driver code
    public static void Main(String []args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(10);
        tree.root.left = new Node(2);
        tree.root.right = new Node(6);
        tree.root.right.right = new Node(5);
        tree.root.left.left = new Node(8);
        tree.root.left.right = new Node(4);
 
        tree.test(tree.root, 10);
        tree.test(tree.root, 2);
        tree.test(tree.root, 6);
        tree.test(tree.root, 5);
        tree.test(tree.root, 8);
        tree.test(tree.root, 4);
    }
}
 
// This code has been contributed
// by 29AjayKumar
Javascript



<script>
 
// Javascript program to find next right of a given key
 
// A binary tree node
class Node
{
    constructor(item)
    {
        this.data = item;
        this.left = this.right = null;
    }
}
 
let root;
 
// Method to find next right of given key k,
// it returns NULL if k is not present in
// tree or k is the rightmost node of its level
function nextRight(first, k)
{
     
    // Base Case
    if (first == null)
        return null;
 
    // Create an empty queue for level
    // order traversal. A queue to
    // store node addresses
    let qn = [];
      
    // Another queue to store node levels
    let ql = [];
     
    // Initialize level as 0
    let level = 0; 
 
    // Enqueue Root and its level
    qn.push(first);
    ql.push(level);
 
    // A standard BFS loop
    while (qn.length != 0)
    {
         
        // dequeue an node from qn and its level from ql
        let node = qn[0];
        level = ql[0];
        qn.shift();
        ql.shift();
 
        // If the dequeued node has the given key k
        if (node.data == k)
        {
             
            // If there are no more items in queue
            // or given node is the rightmost node
            // of its level, then return NULL
            if (ql.length == 0 || ql[0] != level)
                return null;
 
            // Otherwise return next node
            // from queue of nodes
            return qn[0];
        }
 
        // Standard BFS steps: enqueue
        // children of this node
        if (node.left != null)
        {
            qn.push(node.left);
            ql.push(level + 1);
        }
        if (node.right != null)
        {
            qn.push(node.right);
            ql.push(level + 1);
        }
    }
 
    // We reach here if given key
    // x doesn't exist in tree
    return null;
}
 
// A utility function to test above functions
function test(node, k)
{
    let nr = nextRight(root, k);
    if (nr != null)
        document.write("Next Right of " + k +
                       " is " + nr.data + "<br>");
    else
        document.write("No next right node found for " +
                       k + "<br>");
}
 
// Driver code
root = new Node(10);
root.left = new Node(2);
root.right = new Node(6);
root.right.right = new Node(5);
root.left.left = new Node(8);
root.left.right = new Node(4);
   
test(root, 10);
test(root, 2);
test(root, 6);
test(root, 5);
test(root, 8);
test(root, 4);
 
// This code is contributed by rag2127
 
</script>
Output: 
No next right node found for 10
Next Right of 2 is 6
No next right node found for 6
No next right node found for 5
Next Right of 8 is 4
Next Right of 4 is 5
 
Time Complexity: The above code is a simple BFS traversal code which visits every enqueue and dequeues a node at most once. Therefore, the time complexity is O(n) where n is the number of nodes in the given binary tree.
Exercise: Write a function to find left node of a given node. If there is no node on the left side, then return NULL.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 

My Personal Notes
arrow_drop_up
Next

Deepest left leaf node in a binary tree
Recommended Articles
Page :
Find next right node of a given key | Set 2
22, Dec 17
Check whether the sum of element of a node is equal to the given key value
03, Apr 19
Convert left-right representation of a binary tree to down-right
06, Aug 14
Right sibling of each node in a tree given as array of edges
14, Nov 18
Sum of nodes in a linked list which are greater than next node
29, Mar 19
Queries to find sum of distance of a given node to every leaf node in a Weighted Tree
17, Jul 20
Deepest right leaf node in a binary tree | Iterative approach
04, Jan 18
Convert a Binary Tree such that every node stores the sum of all nodes in its right subtree
20, Jun 18
Replace every node of a Linked list with the greatest element on right side
09, Jun 20
Find sum of all right leaves in a given Binary Tree
23, Aug 17
Reduce the given Array of [1, N] by rotating left or right based on given conditions
06, Jul 21
Inorder predecessor and successor for a given key in BST
25, Jul 14
Inorder predecessor and successor for a given key in BST | Iterative Approach
25, Jun 18
Count of numbers in given Array greater than next K elements
08, Dec 21
Find a node such that all paths from that node to leaf nodes are of the same color
20, Jan 21
Find farthest node from each node in Tree
07, May 20
Path from the root node to a given node in an N-ary Tree
17, Jan 21
Check if every node can me made accessible from a node of a Tree by at most N/2 given operations
06, Apr 21
Minimize sum of node values by filling given empty Tree such that each node is GCD of its children
10, Sep 21
Find parent of given node in a Binary Tree with given postorder traversal
09, Jun 20
Find Level wise positions of given node in a given Binary Tree
09, Feb 22
Find largest subtree having identical left and right subtrees
17, Jun 16
Find right sibling of a binary tree with parent pointers
20, Aug 17
Find maximum among all right nodes in Binary Tree
06, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!