Depth of the deepest odd level node in Binary Tree
Given a Binary tree, find out depth of the deepest odd level leaf node. Take root level as depth 1.
Examples:Â
Input :
Output : 5
Input : 10
/ \
28 13
/ \
14 15
/ \
23 24
Output : 3
We can traverse the tree starting from the root level and keep curr_level of the node.Â
Increment the curr_level each time we go to left or a right subtree.Â
Return the max depth of an odd level,if it exists.
Algorithm:Â
1) return 0 if curr_node == NULL
2) if curr_node is leaf and curr_level is odd,
return curr_level
3) else maximum(depthOdd(left subtree),
depthOdd(right subtree))
Below is the implementation.Â
C++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int key;
struct Node *left, *right;
};
Node* newNode( int key)
{
Node* temp = new Node;
temp->key = key;
temp->left = temp->right = NULL;
return (temp);
}
bool isleaf(Node *curr_node)
{
return (curr_node->left == NULL &&
curr_node->right == NULL);
}
int deepestOddLevelDepthUtil(Node *curr_node, int curr_level)
{
if ( curr_node == NULL)
return 0;
curr_level += 1;
if ( curr_level % 2 != 0 && isleaf(curr_node))
return curr_level;
return max(deepestOddLevelDepthUtil(curr_node->left,curr_level),
deepestOddLevelDepthUtil(curr_node->right,curr_level));
}
int deepestOddLevelDepth(Node *curr_node)
{
return deepestOddLevelDepthUtil(curr_node, 0);
}
int main()
{
Node *root = newNode(10);
root->left = newNode(28);
root->right = newNode(13);
root->right->left = newNode(14);
root->right->right = newNode(15);
root->right->right->left = newNode(23);
root->right->right->right = newNode(24);
cout << deepestOddLevelDepth(root) << endl;
return 0;
}
|
Java
class GfG {
static class Node
{
int key;
Node left, right;
}
static Node newNode( int key)
{
Node temp = new Node();
temp.key = key;
temp.left = null ;
temp.right = null ;
return (temp);
}
static boolean isleaf(Node curr_node)
{
return (curr_node.left == null && curr_node.right == null );
}
static int deepestOddLevelDepthUtil(Node curr_node, int curr_level)
{
if ( curr_node == null )
return 0 ;
curr_level += 1 ;
if ( curr_level % 2 != 0 && isleaf(curr_node))
return curr_level;
return Math.max(deepestOddLevelDepthUtil(curr_node.left,curr_level),
deepestOddLevelDepthUtil(curr_node.right,curr_level));
}
static int deepestOddLevelDepth(Node curr_node)
{
return deepestOddLevelDepthUtil(curr_node, 0 );
}
public static void main(String[] args)
{
Node root = newNode( 10 );
root.left = newNode( 28 );
root.right = newNode( 13 );
root.right.left = newNode( 14 );
root.right.right = newNode( 15 );
root.right.right.left = newNode( 23 );
root.right.right.right = newNode( 24 );
System.out.println(deepestOddLevelDepth(root));
}
}
|
Python3
class newNode:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def isleaf(curr_node) :
return (curr_node.left = = None and
curr_node.right = = None )
def deepestOddLevelDepthUtil(curr_node,
curr_level) :
if (curr_node = = None ) :
return 0
curr_level + = 1
if (curr_level % 2 ! = 0 and
isleaf(curr_node)) :
return curr_level
return max (deepestOddLevelDepthUtil(curr_node.left,
curr_level),
deepestOddLevelDepthUtil(curr_node.right,
curr_level))
def deepestOddLevelDepth(curr_node) :
return deepestOddLevelDepthUtil(curr_node, 0 )
if __name__ = = '__main__' :
root = newNode( 10 )
root.left = newNode( 28 )
root.right = newNode( 13 )
root.right.left = newNode( 14 )
root.right.right = newNode( 15 )
root.right.right.left = newNode( 23 )
root.right.right.right = newNode( 24 )
print (deepestOddLevelDepth(root))
|
C#
using System;
class GfG
{
class Node
{
public int key;
public Node left, right;
}
static Node newNode( int key)
{
Node temp = new Node();
temp.key = key;
temp.left = null ;
temp.right = null ;
return (temp);
}
static bool isleaf(Node curr_node)
{
return (curr_node.left == null &&
curr_node.right == null );
}
static int deepestOddLevelDepthUtil(Node curr_node,
int curr_level)
{
if ( curr_node == null )
return 0;
curr_level += 1;
if ( curr_level % 2 != 0 && isleaf(curr_node))
return curr_level;
return Math.Max(deepestOddLevelDepthUtil(curr_node.left,curr_level),
deepestOddLevelDepthUtil(curr_node.right,curr_level));
}
static int deepestOddLevelDepth(Node curr_node)
{
return deepestOddLevelDepthUtil(curr_node, 0);
}
public static void Main(String[] args)
{
Node root = newNode(10);
root.left = newNode(28);
root.right = newNode(13);
root.right.left = newNode(14);
root.right.right = newNode(15);
root.right.right.left = newNode(23);
root.right.right.right = newNode(24);
Console.WriteLine(deepestOddLevelDepth(root));
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .key = 0;
this .left = null ;
this .right = null ;
}
}
function newNode(key)
{
var temp = new Node();
temp.key = key;
temp.left = null ;
temp.right = null ;
return (temp);
}
function isleaf(curr_node)
{
return (curr_node.left == null &&
curr_node.right == null );
}
function deepestOddLevelDepthUtil(curr_node, curr_level)
{
if ( curr_node == null )
return 0;
curr_level += 1;
if ( curr_level % 2 != 0 && isleaf(curr_node))
return curr_level;
return Math.max(deepestOddLevelDepthUtil(curr_node.left,curr_level),
deepestOddLevelDepthUtil(curr_node.right,curr_level));
}
function deepestOddLevelDepth(curr_node)
{
return deepestOddLevelDepthUtil(curr_node, 0);
}
var root = newNode(10);
root.left = newNode(28);
root.right = newNode(13);
root.right.left = newNode(14);
root.right.right = newNode(15);
root.right.right.left = newNode(23);
root.right.right.right = newNode(24);
document.write(deepestOddLevelDepth(root));
</script>
|
Time complexity: O(h) where h is height of given Binary Tree
Auxiliary space: O(1)
Another Approach(Using Level Order Traversal): Simple and easy to understand
Follow the below steps to solve the above problem:
1) Declare ans variable which will store the depth of the deepest odd level leaf node.
2) Initialize a queue and a level variable with 1 and push the root in the queue.
3) Perform level order traversal and if the frontNode is leaf node and value of level is odd then update value of ans variable from level value and continue traversing.
4) After completion of level Order Traversal the ans variable will the store the depth of deepest odd level leaf node and return it.
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 item){
data = item;
left = right = NULL;
}
};
Node* newNode( int value){
return new Node(value);
}
int deepestOddLevelDepth(Node* root){
int ans = -1;
queue<Node*> q;
q.push(root);
int level = 1;
while (!q.empty()){
int n = q.size();
for ( int i = 0; i<n; i++){
Node* frontNode = q.front();
q.pop();
if (level % 2 != 0 && frontNode->left == NULL && frontNode->right == NULL){
ans = level;
}
if (frontNode->left) q.push(frontNode->left);
if (frontNode->right) q.push(frontNode->right);
}
level++;
}
return ans;
}
int main(){
Node *root = newNode(10);
root->left = newNode(28);
root->right = newNode(13);
root->right->left = newNode(14);
root->right->right = newNode(15);
root->right->right->left = newNode(23);
root->right->right->right = newNode(24);
cout << deepestOddLevelDepth(root) << endl;
return 0;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
class Node {
int data;
Node left;
Node right;
Node( int item) {
data = item;
left = right = null ;
}
}
public class Main {
static Node newNode( int value) {
return new Node(value);
}
static int deepestOddLevelDepth(Node root) {
int ans = - 1 ;
Queue<Node> q = new LinkedList<>();
q.add(root);
int level = 1 ;
while (!q.isEmpty()) {
int n = q.size();
for ( int i = 0 ; i < n; i++) {
Node frontNode = q.poll();
if (level % 2 != 0 && frontNode.left == null && frontNode.right == null ) {
ans = level;
}
if (frontNode.left != null ) q.add(frontNode.left);
if (frontNode.right != null ) q.add(frontNode.right);
}
level++;
}
return ans;
}
public static void main(String[] args) {
Node root = newNode( 10 );
root.left = newNode( 28 );
root.right = newNode( 13 );
root.right.left = newNode( 14 );
root.right.right = newNode( 15 );
root.right.right.left = newNode( 23 );
root.right.right.right = newNode( 24 );
System.out.println(deepestOddLevelDepth(root));
}
}
|
Python3
from queue import Queue
class Node:
def __init__( self , item):
self .data = item
self .left = None
self .right = None
def newNode(value):
return Node(value)
def deepestOddLevelDepth(root):
ans = - 1
q = Queue()
q.put(root)
level = 1
while not q.empty():
n = q.qsize()
for i in range (n):
frontNode = q.get()
if level % 2 ! = 0 and frontNode.left is None and frontNode.right is None :
ans = level
if frontNode.left:
q.put(frontNode.left)
if frontNode.right:
q.put(frontNode.right)
level + = 1
return ans
if __name__ = = "__main__" :
root = newNode( 10 )
root.left = newNode( 28 )
root.right = newNode( 13 )
root.right.left = newNode( 14 )
root.right.right = newNode( 15 )
root.right.right.left = newNode( 23 )
root.right.right.right = newNode( 24 )
print (deepestOddLevelDepth(root))
|
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 ;
}
}
public class DeepestOddLevelDepth
{
public static int DeepestOddLevel(Node root)
{
int ans = -1;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
int level = 1;
while (q.Count > 0)
{
int n = q.Count;
for ( int i = 0; i < n; i++)
{
Node frontNode = q.Dequeue();
if (level % 2 != 0 && frontNode.left == null && frontNode.right == null )
{
ans = level;
}
if (frontNode.left != null ) q.Enqueue(frontNode.left);
if (frontNode.right != null ) q.Enqueue(frontNode.right);
}
level++;
}
return ans;
}
public static void Main( string [] args)
{
Node root = new Node(10);
root.left = new Node(28);
root.right = new Node(13);
root.right.left = new Node(14);
root.right.right = new Node(15);
root.right.right.left = new Node(23);
root.right.right.right = new Node(24);
Console.WriteLine( DeepestOddLevel(root));
}
}
|
Javascript
class Node {
constructor(item) {
this .data = item;
this .left = null ;
this .right = null ;
}
}
function deepestOddLevelDepth(root) {
let ans = -1;
let queue = [root];
let level = 1;
while (queue.length > 0) {
const n = queue.length;
for (let i = 0; i < n; i++) {
const frontNode = queue.shift();
if (level % 2 !== 0 && frontNode.left === null && frontNode.right === null ) {
ans = level;
}
if (frontNode.left) queue.push(frontNode.left);
if (frontNode.right) queue.push(frontNode.right);
}
level++;
}
return ans;
}
function newNode(value) {
return new Node(value);
}
let root = newNode(10);
root.left = newNode(28);
root.right = newNode(13);
root.right.left = newNode(14);
root.right.right = newNode(15);
root.right.right.left = newNode(23);
root.right.right.right = newNode(24);
console.log(deepestOddLevelDepth(root));
|
Time Complexity: O(N), where N is the number of nodes in given binary tree.
Auxiliary Space: O(N) due to queue data structure.
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Â
Last Updated :
12 Jan, 2024
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...