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, maintain “level” which will store the current node’s level in the tree. If current node is left leaf, then check if its level is more than the level of deepest left leaf seen so far. If level is more then update the result. If current node is not leaf, then recursively find maximum depth in left and right subtrees, and return maximum of the two depths.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int val;
struct Node *left, *right;
};
Node *newNode( int data)
{
Node *temp = new Node;
temp->val = data;
temp->left = temp->right = NULL;
return temp;
}
void deepestLeftLeafUtil(Node *root, int lvl, int *maxlvl,
bool isLeft, Node **resPtr)
{
if (root == NULL)
return ;
if (isLeft && !root->left && !root->right && lvl > *maxlvl)
{
*resPtr = root;
*maxlvl = lvl;
return ;
}
deepestLeftLeafUtil(root->left, lvl+1, maxlvl, true , resPtr);
deepestLeftLeafUtil(root->right, lvl+1, maxlvl, false , resPtr);
}
Node* deepestLeftLeaf(Node *root)
{
int maxlevel = 0;
Node *result = NULL;
deepestLeftLeafUtil(root, 0, &maxlevel, false , &result);
return result;
}
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = 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 = deepestLeftLeaf(root);
if (result)
cout << "The deepest left child is " << result->val;
else
cout << "There is no left leaf in the given tree" ;
return 0;
}
|
Java
class Node
{
int data;
Node left, right;
public Node( int data)
{
this .data = data;
left = right = null ;
}
}
class Level
{
int maxlevel = 0 ;
}
class BinaryTree
{
Node root;
Node result;
void deepestLeftLeafUtil(Node node,
int lvl,
Level level,
boolean isLeft)
{
if (node == null )
return ;
if (isLeft != false &&
node.left == null &&
node.right == null &&
lvl > level.maxlevel)
{
result = node;
level.maxlevel = lvl;
}
deepestLeftLeafUtil(node.left, lvl + 1 ,
level, true );
deepestLeftLeafUtil(node.right, lvl + 1 ,
level, false );
}
void deepestLeftLeaf(Node node)
{
Level level = new Level();
deepestLeftLeafUtil(node, 0 , level, false );
}
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node( 1 );
tree.root.left = new Node( 2 );
tree.root.right = new Node( 3 );
tree.root.left.left = new Node( 4 );
tree.root.right.left = new Node( 5 );
tree.root.right.right = new Node( 6 );
tree.root.right.left.right = new Node( 7 );
tree.root.right.right.right = new Node( 8 );
tree.root.right.left.right.left = new Node( 9 );
tree.root.right.right.right.right = new Node( 10 );
tree.deepestLeftLeaf(tree.root);
if (tree.result != null )
System.out.println( "The deepest left child" +
" is " + tree.result.data);
else
System.out.println( "There is no left leaf in" +
" the given tree" );
}
}
|
Python3
class Node:
def __init__( self , val):
self .val = val
self .left = None
self .right = None
def deepestLeftLeafUtil(root, lvl, maxlvl, isLeft):
if root is None :
return
if (isLeft is True ):
if (root.left = = None and root.right = = None ):
if lvl > maxlvl[ 0 ] :
deepestLeftLeafUtil.resPtr = root
maxlvl[ 0 ] = lvl
return
deepestLeftLeafUtil(root.left, lvl + 1 , maxlvl, True )
deepestLeftLeafUtil(root.right, lvl + 1 , maxlvl, False )
def deepestLeftLeaf(root):
maxlvl = [ 0 ]
deepestLeftLeafUtil.resPtr = None
deepestLeftLeafUtil(root, 0 , maxlvl, False )
return deepestLeftLeafUtil.resPtr
root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.right.left = Node( 5 )
root.right.right = Node( 6 )
root.right.left.right = Node( 7 )
root.right.right.right = Node( 8 )
root.right.left.right.left = Node( 9 )
root.right.right.right.right = Node( 10 )
result = deepestLeftLeaf(root)
if result is None :
print ( "There is not left leaf in the given tree" )
else :
print ( "The deepst left child is" , result.val)
|
C#
using System;
public class Node
{
public int data;
public Node left, right;
public Node( int data)
{
this .data = data;
left = right = null ;
}
}
public class Level
{
public int maxlevel = 0;
}
public class BinaryTree
{
public Node root;
public Node result;
public virtual void deepestLeftLeafUtil(Node node, int lvl,
Level level, bool isLeft)
{
if (node == null )
{
return ;
}
if (isLeft != false && node.left == null && node.right == null
&& lvl > level.maxlevel)
{
result = node;
level.maxlevel = lvl;
}
deepestLeftLeafUtil(node.left, lvl + 1, level, true );
deepestLeftLeafUtil(node.right, lvl + 1, level, false );
}
public virtual void deepestLeftLeaf(Node node)
{
Level level = new Level();
deepestLeftLeafUtil(node, 0, level, false );
}
public static void Main( string [] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.right.left = new Node(5);
tree.root.right.right = new Node(6);
tree.root.right.left.right = new Node(7);
tree.root.right.right.right = new Node(8);
tree.root.right.left.right.left = new Node(9);
tree.root.right.right.right.right = new Node(10);
tree.deepestLeftLeaf(tree.root);
if (tree.result != null )
{
Console.WriteLine( "The deepest left child is " + tree.result.data);
}
else
{
Console.WriteLine( "There is no left leaf in the given tree" );
}
}
}
|
Javascript
<script>
class Node
{
constructor(data)
{
this .left = null ;
this .right = null ;
this .data = data;
}
}
let maxlevel = 0;
let root;
let result;
function deepestLeftLeafUtil(node, lvl, isLeft)
{
if (node == null )
return ;
if (isLeft != false &&
node.left == null &&
node.right == null &&
lvl > maxlevel)
{
result = node;
maxlevel = lvl;
}
deepestLeftLeafUtil(node.left, lvl + 1, true );
deepestLeftLeafUtil(node.right, lvl + 1, false );
}
function deepestLeftLeaf(node)
{
deepestLeftLeafUtil(node, 0, false );
}
root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(6);
root.right.left.right = new Node(7);
root.right.right.right = new Node(8);
root.right.left.right.left = new Node(9);
root.right.right.right.right = new Node(10);
deepestLeftLeaf(root);
if (result != null )
document.write( "The deepest left child" +
" is " + result.data + "</br>" );
else
document.write( "There is no left leaf in" +
" the given tree" );
</script>
|
Output
The deepest left child is 9
Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).
Auxiliary Space: O(n) for call stack because using recursion
Iterative Approach(Using Level Order Traversal):
Follow the below steps to solve the above problem:
1) We simply traverse the tree using Level Order Traversal with queue data structure.
2) If current node has left child then we update our answer with left child.
3) Finally return the ans node.
Below is the implementation of above approach:
C++
#include<bits/stdc++.h>
using namespace std;
struct Node{
int data;
Node* left;
Node* right;
Node( int data){
this ->data = data;
this ->left = NULL;
this ->right = NULL;
}
};
Node* newNode( int data){
return new Node(data);
}
Node* deepestLeftLeaf(Node* root){
if (root == NULL) return NULL;
Node* ans = NULL;
queue<Node*> q;
q.push(root);
while (!q.empty()){
Node* front_node = q.front();
q.pop();
if (front_node->left){
q.push(front_node->left);
ans = front_node->left;
}
if (front_node->right){
q.push(front_node->right);
}
}
return ans;
}
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = 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 = deepestLeftLeaf(root);
if (result)
cout << "The deepest left child is " << result->data;
else
cout << "There is no left leaf in the given tree" ;
return 0;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
class Node {
int data;
Node left, right;
public Node( int item) {
data = item;
left = right = null ;
}
}
public class Main {
static Node newNode( int data) {
return new Node(data);
}
static Node deepestLeftLeaf(Node root) {
if (root == null ) return null ;
Node ans = null ;
Queue<Node> q = new LinkedList<Node>();
q.add(root);
while (!q.isEmpty()) {
Node front_node = q.poll();
if (front_node.left != null ) {
q.add(front_node.left);
ans = front_node.left;
}
if (front_node.right != null ) q.add(front_node.right);
}
return ans;
}
public static void main(String[] args) {
Node root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = 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 = deepestLeftLeaf(root);
if (result != null ) {
System.out.println( "The deepest left child is : " + result.data);
} else {
System.out.println( "There is no left leaf in the given tree." );
}
}
}
|
Python
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def newNode(data):
return Node(data)
def deepestLeftLeaf(root):
if (root is None ):
return
ans = None
q = []
q.append(root)
while ( len (q) > 0 ):
front_node = q.pop( 0 )
if (front_node.left is not None ):
q.append(front_node.left)
ans = front_node.left
if (front_node.right is not None ):
q.append(front_node.right)
return ans
root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = 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 = deepestLeftLeaf(root)
if (result is not None ):
print ( "The deepest left child is : " )
print (result.data)
else :
print ( "There is no left leaf in the given tree." )
|
C#
using System;
using System.Collections.Generic;
public class Node{
public int data;
public Node left, right;
public Node( int item){
data = item;
left = right = null ;
}
}
class GFG{
static Node newNode( int data){
return new Node(data);
}
static Node deepestLeftLeaf(Node root){
if (root == null ) return null ;
Node ans = null ;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count > 0){
Node front_node = q.Dequeue();
if (front_node.left != null ){
q.Enqueue(front_node.left);
ans = front_node.left;
}
if (front_node.right != null ) q.Enqueue(front_node.right);
}
return ans;
}
public static void Main(String[] args){
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = 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 = deepestLeftLeaf(root);
if (result != null ){
Console.WriteLine( "The deepest left child is : " + result.data);
}
else {
Console.WriteLine( "There is no left leaf in the given tree." );
}
}
}
|
Javascript
class Node{
constructor(data){
this .data = data;
this .left = null ;
this .right = null ;
}
}
function newNode(data){
return new Node(data);
}
function deepestLeftLeaf(root){
if (root == null ) return null ;
let ans = null ;
let q = [];
q.push(root);
while (q.length > 0){
let front_node = q.shift();
if (front_node.left){
q.push(front_node.left);
ans = front_node.left;
}
if (front_node.right) q.push(front_node.right);
}
return ans;
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = 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 = deepestLeftLeaf(root);
if (result)
console.log( "The deepest left child is : " + result.data);
else
console.log( "There is no left leaf in the given tree." );
|
Output
The deepest left child is 9
Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(N) due to queue data structure.
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!