Deepest right leaf node in a binary tree | Iterative approach

Given a Binary Tree, find the deepest leaf node that is right child of its parent. For example, consider the following tree. The deepest right leaf node is the node with value 10.

Examples:

Input : 
       1
     /   \
    2     3
     \   /  \  
      4 5    6
         \    \
          7    8
         /      \
        9        10

Output : 10



The idea is similar to Method 2 of level order traversal

Traverse the tree level by level and while pushing right child to queue, check if it is leaf node, if it’s leaf node, then update the result and since we are traversing level by level, the last stored right leaf will be the deepest right leaf node.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find deepest right leaf
// node of binary tree
#include <bits/stdc++.h>
using namespace std;
   
// tree node
struct Node {
    int data;
    Node *left, *right;
};
   
// returns a new tree Node
Node* newNode(int data)
{
    Node* temp = new Node();
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
   
// return the deepest right leaf node
// of binary tree
Node* getDeepestRightLeafNode(Node* root)
{
    if (!root)
        return NULL;
   
    // create a queue for level order traversal
    queue<Node*> q;
    q.push(root);
   
    Node* result = NULL;
   
    // traverse until the queue is empty
    while (!q.empty()) {
        Node* temp = q.front();
        q.pop();
   
          
        if (temp->left) {
            q.push(temp->left);
        }
          
        // Since we go level by level, the last 
        // stored right leaf node is deepest one 
        if (temp->right){
            q.push(temp->right);
            if (!temp->right->left && !temp->right->right)
                result = temp->right;
        }
    }
    return result;
}
   
// driver program
int main()
{
    // construct a tree
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->right = newNode(4);
    root->right->left = newNode(5);
    root->right->right = newNode(6);
    root->right->left->right = newNode(7);
    root->right->right->right = newNode(8);
    root->right->left->right->left = newNode(9);
    root->right->right->right->right = newNode(10);
   
    Node* result = getDeepestRightLeafNode(root);
    if (result)
        cout << "Deepest Right Leaf Node :: "
             << result->data << endl;
    else
        cout << "No result, right leaf not found\n";
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java program to find deepest right leaf 


// node of binary tree 


import java.util.*; 


  


class GFG 


{ 


  


  


// tree node 


static class Node  


{ 


    int data; 


    Node left, right; 


}; 


  


// returns a new tree Node 


static Node newNode(int data) 


{ 


    Node temp = new Node(); 


    temp.data = data; 


    temp.left = temp.right = null; 


    return temp; 


} 


  


// return the deepest right leaf node 


// of binary tree 


static Node getDeepestRightLeafNode(Node root) 


{ 


    if (root == null) 


        return null; 


  


    // create a queue for level order traversal 


    Queue<Node> q = new LinkedList<>(); 


    q.add(root); 


  


    Node result = null; 


  


    // traverse until the queue is empty 


    while (!q.isEmpty())  


    { 


        Node temp = q.peek(); 


        q.poll(); 


  


          


        if (temp.left != null) 


        { 


            q.add(temp.left); 


        } 


          


        // Since we go level by level, the last  


        // stored right leaf node is deepest one  


        if (temp.right != null) 


        { 


            q.add(temp.right); 


            if (temp.right.left == null && temp.right.right == null) 


                result = temp.right; 


        } 


    } 


    return result; 


} 


  


// Driver code 


public static void main(String[] args)  


{ 


      


    // construct a tree 


    Node root = newNode(1); 


    root.left = newNode(2); 


    root.right = newNode(3); 


    root.left.right = newNode(4); 


    root.right.left = newNode(5); 


    root.right.right = newNode(6); 


    root.right.left.right = newNode(7); 


    root.right.right.right = newNode(8); 


    root.right.left.right.left = newNode(9); 


    root.right.right.right.right = newNode(10); 


  


    Node result = getDeepestRightLeafNode(root); 


    if (result != null) 


        System.out.println("Deepest Right Leaf Node :: "


            + result.data); 


    else


        System.out.println("No result, right leaf not found\n"); 


    } 


} 


  


/* This code is contributed by PrinciRaj1992 */



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to find closest  


# value in Binary search Tree 


  


_MIN = -2147483648


_MAX = 2147483648


  


# Helper function that allocates a new  


# node with the given data and None   


# left and right poers.                                      


class newnode:  


  


    # Constructor to create a new node  


    def __init__(self, data):  


        self.data = data  


        self.left = None


        self.right = None


  


# utility function to return level  


# of given node 


def getDeepestRightLeafNode(root) : 


  


    if (not root): 


        return None


  


    # create a queue for level  


    # order traversal  


    q = []  


    q.append(root)  


  


    result = None


  


    # traverse until the queue is empty  


    while (len(q)):  


        temp = q[0]  


        q.pop(0)  


  


        if (temp.left): 


            q.append(temp.left)  


          


        # Since we go level by level, the last  


        # stored right leaf node is deepest one  


        if (temp.right):  


            q.append(temp.right)  


            if (not temp.right.left and


                not temp.right.right):  


                result = temp.right  


  


    return result 


  


# Driver Code  


if __name__ == '__main__': 


      


    # create a binary tree  


    root = newnode(1)  


    root.left = newnode(2)  


    root.right = newnode(3)  


    root.left.right = newnode(4) 


    root.right.left = newnode(5)  


    root.right.right = newnode(6) 


    root.right.left.right = newnode(7) 


    root.right.right.right = newnode(8) 


    root.right.left.right.left = newnode(9) 


    root.right.right.right.right = newnode(10)  


  


    result = getDeepestRightLeafNode(root) 


    if result: 


        print("Deepest Right Leaf Node ::", 


                               result.data) 


    else: 


        print("No result, right leaf not found") 


          


# This code is contributed by 


# Shubham Singh(SHUBHAMSINGH10) 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# program to find deepest right leaf 


// node of binary tree 


using System; 


using System.Collections.Generic;  


      


class GFG 


{ 


  


  


// tree node 


public class Node  


{ 


    public int data; 


    public Node left, right; 


}; 


  


// returns a new tree Node 


static Node newNode(int data) 


{ 


    Node temp = new Node(); 


    temp.data = data; 


    temp.left = temp.right = null; 


    return temp; 


} 


  


// return the deepest right leaf node 


// of binary tree 


static Node getDeepestRightLeafNode(Node root) 


{ 


    if (root == null) 


        return null; 


  


    // Create a queue for level order traversal 


    Queue<Node> q = new Queue<Node>(); 


    q.Enqueue(root); 


  


    Node result = null; 


  


    // Traverse until the queue is empty 


    while (q.Count!=0)  


    { 


        Node temp = q.Peek(); 


        q.Dequeue(); 


  


          


        if (temp.left != null) 


        { 


            q.Enqueue(temp.left); 


        } 


          


        // Since we go level by level, the last  


        // stored right leaf node is deepest one  


        if (temp.right != null) 


        { 


            q.Enqueue(temp.right); 


            if (temp.right.left == null && temp.right.right == null) 


                result = temp.right; 


        } 


    } 


    return result; 


} 


  


// Driver code 


public static void Main(String[] args)  


{ 


      


    // construct a tree 


    Node root = newNode(1); 


    root.left = newNode(2); 


    root.right = newNode(3); 


    root.left.right = newNode(4); 


    root.right.left = newNode(5); 


    root.right.right = newNode(6); 


    root.right.left.right = newNode(7); 


    root.right.right.right = newNode(8); 


    root.right.left.right.left = newNode(9); 


    root.right.right.right.right = newNode(10); 


  


    Node result = getDeepestRightLeafNode(root); 


    if (result != null) 


        Console.WriteLine("Deepest Right Leaf Node :: "


            + result.data); 


    else


        Console.WriteLine("No result, right leaf not found\n"); 


} 


} 


  


// This code is contributed by Princi Singh 



















                        chevron_right







                        filter_none












Output:


Deepest Right Leaf Node :: 10



Time Complexity :  O(n)







– Mandeep Singh



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
msdeep14
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 : 
Tree

           	
Practice Tags : 
Tree

        

         

         
 
                1

                

        



        
        
        
        
        

    

            

            3
            

            

             
                 Based on 4 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


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