Deepest right leaf node in a binary tree | Iterative approach
Last Updated :
17 Mar, 2023
Given a Binary Tree, find the deepest leaf node that is the right child of its parent. For example, consider the following tree. The deepest right leaf node is the node with the 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 the level by level, the last stored right leaf will be the deepest right leaf node.
Algorithm:
- Start with the root node of the binary tree.
- Create a queue for level order traversal.
- Push the root node into the queue.
- Initialize a variable named result to NULL.
- Traverse the tree level by level using the queue until the queue is empty.
- For each node, first check if it has a left child. If yes, then push it into the queue.
- Then check if it has a right child. If yes, then push it into the queue.
- If the node has a right child and it is a leaf node (i.e., both its left and right child are NULL), then update the result variable with this node.
- Once the traversal is complete, result will hold the deepest right leaf node of the binary tree.
- Return result.
Implementation:
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 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 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 pointers.
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# 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
<script>
// JavaScript program to find deepest right leaf
// node of binary tree
/* A binary tree node has data, pointer to
left child and a pointer to right child */
class Node
{
constructor(data) {
this.left = null;
this.right = null;
this.data = data;
}
}
// returns a new tree Node
function newNode(data)
{
let temp = new Node(data);
return temp;
}
// return the deepest right leaf node
// of binary tree
function getDeepestRightLeafNode(root)
{
if (root == null)
return null;
// create a queue for level order traversal
let q = [];
q.push(root);
let result = null;
// traverse until the queue is empty
while (q.length > 0)
{
let temp = q[0];
q.shift();
if (temp.left != null)
{
q.push(temp.left);
}
// Since we go level by level, the last
// stored right leaf node is deepest one
if (temp.right != null)
{
q.push(temp.right);
if (temp.right.left == null &&
temp.right.right == null)
result = temp.right;
}
}
return result;
}
// construct a tree
let 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);
let result = getDeepestRightLeafNode(root);
if (result != null)
document.write("Deepest Right Leaf Node :: "
+ result.data);
else
document.write("No result, right leaf not found");
</script>
OutputDeepest Right Leaf Node :: 10
Time Complexity: O(n)
Auxiliary Space: O(n) because using queue
Similar Reads
Deepest left leaf node in a binary tree | iterative approach Given a Binary Tree, find the deepest leaf node that is left child of its parent. For example, consider the following tree. The deepest left leaf node is the node with value 9. Examples: Input : 1 / \ 2 3 / / \ 4 5 6 \ \ 7 8 / \ 9 10 Output : 9 Recursive approach to this problem is discussed hereFor
8 min read
Get level of a node in binary tree | iterative approach Given a Binary Tree and a key, write a function that returns level of the key. For example, consider the following tree. If the input key is 3, then your function should return 1. If the input key is 4, then your function should return 3. And for key which is not present in key, then your function s
10 min read
Iterative approach to check if a Binary Tree is Perfect Given a Binary Tree, the task is to check whether the given Binary Tree is a perfect Binary Tree or not.A Binary tree is a Perfect Binary Tree in which all internal nodes have two children and all leaves are at the same level.Examples: Input : 1 / \ 2 3 / \ / \ 4 5 6 7 Output : Yes Input : 20 / \ 8
9 min read
Deepest left leaf node in a binary tree Given a Binary Tree, find the deepest leaf node that is left child of its parent. For example, consider the following tree. The deepest left leaf node is the node with value 9. 1 / \ 2 3 / / \ 4 5 6 \ \ 7 8 / \ 9 10 The idea is to recursively traverse the given binary tree and while traversing, main
13 min read
Sum of nodes at maximum depth of a Binary Tree | Iterative Approach Given a root node to a tree, find the sum of all the leaf nodes which are at maximum depth from the root node.Example: 1 / \ 2 3 / \ / \ 4 5 6 7Input : root(of above tree)Output : 22Explanation:Nodes at maximum depth are 4, 5, 6, 7. So, the sum of these nodes = 22Approach: There exists a recursive a
7 min read