Deepest right leaf node in a binary tree | Iterative approach

Difficulty Level : Medium
Last Updated : 04 Jul, 2019

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

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

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

// 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;
}

Java

// 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 */

Python3

# 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)

C#

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

Output:

Deepest Right Leaf Node :: 10

Time Complexity : O(n)

– Mandeep Singh

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes