Find depth of the deepest odd level leaf node - GeeksforGeeks

20 Jan, 2022
Write a code to get the depth of the deepest odd level leaf node in a binary tree. Consider that level starts with 1. Depth of a leaf node is number of nodes on the path from root to leaf (including both leaf and root).For example, consider the following tree. The deepest odd level node is the node with value 9 and depth of this node is 5.  
       1
     /   \
    2     3
  /      /  \  
 4      5    6
        \     \
         7     8
        /       \
       9         10
                 /
                11
 
The idea is to recursively traverse the given binary tree and while traversing, maintain a variable “level” which will store the current node’s level in the tree. If current node is leaf then check “level” is odd or not. If level is odd then return it. If current node is not leaf, then recursively find maximum depth in left and right subtrees, and return maximum of the two depths. 
C++
C
Java
Python3
C#
Javascript
// C++ program to find depth of the// deepest odd level leaf node#include <bits/stdc++.h>using namespace std; // A utility function to find// maximum of two integersint max(int x, int y){    return (x > y)? x : y;} // A Binary Tree nodestruct Node{    int data;    struct Node *left, *right;}; // A utility function to allocate a// new tree nodestruct Node* newNode(int data){    struct Node* node = (struct Node*) malloc(sizeof(struct Node));    node->data = data;    node->left = node->right = NULL;    return node;} // A recursive function to find depth of// the deepest odd level leafint depthOfOddLeafUtil(struct Node *root,                               int level){    // Base Case    if (root == NULL)        return 0;     // If this node is a leaf and its level    // is odd, return its level    if (root->left == NULL &&        root->right == NULL && level & 1)        return level;     // If not leaf, return the maximum value    // from left and right subtrees    return max(depthOfOddLeafUtil(root->left, level + 1),               depthOfOddLeafUtil(root->right, level + 1));} /* Main function which calculates the depth   of deepest odd level leaf. This function   mainly uses depthOfOddLeafUtil() */int depthOfOddLeaf(struct Node *root){    int level = 1, depth = 0;    return depthOfOddLeafUtil(root, level);} // Driver Codeint main(){    struct 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);    root->right->right->right->right->left = newNode(11);     cout << depthOfOddLeaf(root)         << " is the required depth";    getchar();    return 0;} // This code is contributed// by Akanksha Rai
// C program to find depth of the deepest odd level leaf node#include <stdio.h>#include <stdlib.h> // A utility function to find maximum of two integersint max(int x, int y) { return (x > y)? x : y; } // A Binary Tree nodestruct Node{    int data;    struct Node *left, *right;}; // A utility function to allocate a new tree nodestruct Node* newNode(int data){    struct Node* node = (struct Node*) malloc(sizeof(struct Node));    node->data = data;    node->left = node->right = NULL;    return node;} // A recursive function to find depth of the deepest odd level leafint depthOfOddLeafUtil(struct Node *root,int level){    // Base Case    if (root == NULL)        return 0;     // If this node is a leaf and its level is odd, return its level    if (root->left==NULL && root->right==NULL && level&1)        return level;     // If not leaf, return the maximum value from left and right subtrees    return max(depthOfOddLeafUtil(root->left, level+1),            depthOfOddLeafUtil(root->right, level+1));} /* Main function which calculates the depth of deepest odd level leaf.This function mainly uses depthOfOddLeafUtil() */int depthOfOddLeaf(struct Node *root){    int level = 1, depth = 0;    return depthOfOddLeafUtil(root, level);} // Driver program to test above functionsint main(){    struct 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);    root->right->right->right->right->left = newNode(11);     printf("%d is the required depth\n", depthOfOddLeaf(root));    getchar();    return 0;}
// Java program to find depth of deepest odd level node // A binary tree nodeclass Node{    int data;    Node left, right;      Node(int item)    {        data = item;        left = right = null;    }}  class BinaryTree{    Node root;      // A recursive function to find depth of the deepest odd level leaf    int depthOfOddLeafUtil(Node node, int level)    {        // Base Case        if (node == null)            return 0;          // If this node is a leaf and its level is odd, return its level        if (node.left == null && node.right == null && (level & 1) != 0)            return level;          // If not leaf, return the maximum value from left and right subtrees        return Math.max(depthOfOddLeafUtil(node.left, level + 1),                depthOfOddLeafUtil(node.right, level + 1));    }      /* Main function which calculates the depth of deepest odd level leaf.       This function mainly uses depthOfOddLeafUtil() */    int depthOfOddLeaf(Node node)    {        int level = 1, depth = 0;        return depthOfOddLeafUtil(node, level);    }      public static void main(String args[])    {        int k = 45;        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.root.right.right.right.right.left = new Node(11);        System.out.println(tree.depthOfOddLeaf(tree.root) +                                                   " is the required depth");    }}  // This code has been contributed by Mayank Jaiswal
# Python program to find depth of the deepest odd level# leaf node # A Binary tree nodeclass Node:         # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # A recursive function to find depth of the deepest# odd level leaf nodedef depthOfOddLeafUtil(root, level):         # Base Case    if root is None:        return 0     # If this node is leaf and its level is odd, return    # its level    if root.left is None and root.right is None and level&1:        return level         # If not leaf, return the maximum value from left    # and right subtrees    return (max(depthOfOddLeafUtil(root.left, level+1),                depthOfOddLeafUtil(root.right, level+1))) # Main function which calculates the depth of deepest odd# level leaf .# This function mainly uses depthOfOddLeafUtil()def depthOfOddLeaf(root):    level = 1    depth = 0    return depthOfOddLeafUtil(root, level) # Driver program to test above functionroot = 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)root.right.right.right.right.left= Node(11) print ("%d is the required depth" %(depthOfOddLeaf(root))) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
using System; // C# program to find depth of deepest odd level node // A binary tree nodepublic class Node{    public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} public class BinaryTree{    public Node root;     // A recursive function to find depth of the deepest odd level leaf    public virtual int depthOfOddLeafUtil(Node node, int level)    {        // Base Case        if (node == null)        {            return 0;        }         // If this node is a leaf and its level is odd, return its level        if (node.left == null && node.right == null && (level & 1) != 0)        {            return level;        }         // If not leaf, return the maximum value from left and right subtrees        return Math.Max(depthOfOddLeafUtil(node.left, level + 1),                        depthOfOddLeafUtil(node.right, level + 1));    }     /* Main function which calculates the depth of deepest odd level leaf.    This function mainly uses depthOfOddLeafUtil() */    public virtual int depthOfOddLeaf(Node node)    {        int level = 1, depth = 0;        return depthOfOddLeafUtil(node, level);    }     public static void Main(string[] args)    {        int k = 45;        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.root.right.right.right.right.left = new Node(11);        Console.WriteLine(tree.depthOfOddLeaf(tree.root) + " is the required depth");    }} // This code is contributed by Shrikant13
<script> // JavaScript program to find depth of// deepest odd level node // A binary tree nodeclass Node {    constructor(val) {        this.data = val;        this.left = null;        this.right = null;    }}     var root;     // A recursive function to find depth of the    // deepest odd level leaf    function depthOfOddLeafUtil(node , level) {        // Base Case        if (node == null)            return 0;         // If this node is a leaf and its level is odd,        // return its level        if (node.left == null && node.right ==            null && (level & 1) != 0)            return level;         // If not leaf, return the maximum value        // from left and right subtrees        return Math.max(depthOfOddLeafUtil(node.left, level + 1),        depthOfOddLeafUtil(node.right, level + 1));    }     /*     * Main function which calculates the     depth of deepest odd level leaf. This     * function mainly uses depthOfOddLeafUtil()     */    function depthOfOddLeaf(node) {        var level = 1, depth = 0;        return depthOfOddLeafUtil(node, level);    }              var k = 45;             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);        root.right.right.right.right.left = new Node(11);                 document.write(        depthOfOddLeaf(root) + " is the required depth"        ); // This code contributed by Rajput-Ji </script>
Output: 
5 is the required depth
Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).Iterative Approach This approach is contributed by Mandeep Singh. Traverse the tree in iterative fashion for each level, and whenever you encounter the leaf node, check if level is odd, if level is odd, then update the result.  
C++
Java
Python3
C#
Javascript
// CPP program to find// depth of the deepest// odd level leaf node// of binary tree#include <bits/stdc++.h>using namespace std; // tree nodestruct Node{    int data;    Node *left, *right;}; // returns a new// tree NodeNode* newNode(int data){    Node* temp = new Node();    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // return max odd number// depth of leaf nodeint maxOddLevelDepth(Node* root){    if (!root)        return 0;     // create a queue    // for level order    // traversal    queue<Node*> q;    q.push(root);     int result = INT_MAX;    int level = 0;     // traverse until the    // queue is empty    while (!q.empty())    {        int size = q.size();        level += 1;         // traverse for        // complete level        while(size > 0)        {            Node* temp = q.front();            q.pop();             // check if the node is            // leaf node and level            // is odd if level is            // odd, then update result            if(!temp->left && !temp->right                      && (level % 2 != 0))            {                result = level;            }                     // check for left child            if (temp->left)            {                q.push(temp->left);            }                         // check for right child            if (temp->right)            {                q.push(temp->right);            }            size -= 1;        }    }         return result;} // driver programint main(){    // construct a tree    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);    root->right->right->right->right->left = newNode(11);     int result = maxOddLevelDepth(root);         if (result == INT_MAX)        cout << "No leaf node at odd level\n";    else        cout << result;        cout << " is the required depth " << endl;    return 0;}
// Java program to find depth of the deepest// odd level leaf node of binary treeimport java.util.*; class GFG{ // tree nodestatic class Node{    int data;    Node left, right;}; // returns a new tree Nodestatic Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // return max odd number depth of leaf nodestatic int maxOddLevelDepth(Node root){    if (root == null)        return 0;     // create a queue for level order    // traversal    Queue<Node> q = new LinkedList<>();    q.add(root);     int result = Integer.MAX_VALUE;    int level = 0;     // traverse until the queue is empty    while (!q.isEmpty())    {        int size = q.size();        level += 1;         // traverse for complete level        while(size > 0)        {            Node temp = q.peek();            q.remove();             // check if the node is leaf node and            // level is odd if level is odd,            // then update result            if(temp.left == null &&               temp.right == null && (level % 2 != 0))            {                result = level;            }                     // check for left child            if (temp.left != null)            {                q.add(temp.left);            }                         // check for right child            if (temp.right != null)            {                q.add(temp.right);            }            size -= 1;        }    }    return result;} // Driver Codepublic static void main(String[] args){    // construct a tree    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);    root.right.right.right.right.left = newNode(11);     int result = maxOddLevelDepth(root);         if (result == Integer.MAX_VALUE)        System.out.println("No leaf node at odd level");    else    {        System.out.print(result);        System.out.println(" is the required depth ");    }}} // This code is contributed by Rajput-Ji
# Python3 program to find depth of the deepest# odd level leaf node of binary tree INT_MAX = 2**31 # tree node returns a new tree Nodeclass newNode:    def __init__(self, data):        self.data = data        self.left = self.right = None         # return max odd number depth# of leaf nodedef maxOddLevelDepth(root) :     if (not root):        return 0     # create a queue for level order    # traversal    q = []    q.append(root)     result = INT_MAX    level = 0     # traverse until the queue is empty    while (len(q)) :             size = len(q)        level += 1         # traverse for complete level        while(size > 0) :                     temp = q[0]            q.pop(0)             # check if the node is leaf node            # and level is odd if level is            # odd, then update result            if(not temp.left and not temp.right                    and (level % 2 != 0)) :                             result = level                         # check for left child            if (temp.left) :                             q.append(temp.left)                         # check for right child            if (temp.right) :                             q.append(temp.right)                         size -= 1         return result # Driver Codeif __name__ == '__main__':    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)    root.right.right.right.right.left = newNode(11)     result = maxOddLevelDepth(root)    if (result == INT_MAX) :        print("No leaf node at odd level")    else:        print(result, end = "")        print(" is the required depth ")         # This code is contributed# by SHUBHAMSINGH10
// C# program to find depth of the deepest// odd level leaf node of binary treeusing System;using System.Collections.Generic;     class GFG{ // tree nodepublic class Node{    public int data;    public Node left, right;}; // returns a new tree Nodestatic Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // return max odd number depth of leaf nodestatic int maxOddLevelDepth(Node root){    if (root == null)        return 0;     // create a queue for level order    // traversal    Queue<Node> q = new Queue<Node>();    q.Enqueue(root);     int result = int.MaxValue;    int level = 0;     // traverse until the queue is empty    while (q.Count != 0)    {        int size = q.Count;        level += 1;         // traverse for complete level        while(size > 0)        {            Node temp = q.Peek();            q.Dequeue();             // check if the node is leaf node and            // level is odd if level is odd,            // then update result            if(temp.left == null &&               temp.right == null &&              (level % 2 != 0))            {                result = level;            }                     // check for left child            if (temp.left != null)            {                q.Enqueue(temp.left);            }                         // check for right child            if (temp.right != null)            {                q.Enqueue(temp.right);            }            size -= 1;        }    }    return result;} // Driver Codepublic static void Main(String[] args){    // construct a tree    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);    root.right.right.right.right.left = newNode(11);     int result = maxOddLevelDepth(root);         if (result == int.MaxValue)        Console.WriteLine("No leaf node at odd level");    else    {        Console.Write(result);        Console.WriteLine(" is the required depth ");    }}} // This code is contributed by PrinciRaj1992
<script>       // JavaScript program to find depth of the deepest      // odd level leaf node of binary tree      // tree node      class Node {        constructor() {          this.data = 0;          this.left = null;          this.right = null;        }      }       // returns a new tree Node      function newNode(data) {        var temp = new Node();        temp.data = data;        temp.left = temp.right = null;        return temp;      }       // return max odd number depth of leaf node      function maxOddLevelDepth(root) {        if (root == null) return 0;         // create a queue for level order        // traversal        var q = [];        q.push(root);         var result = 2147483647;        var level = 0;         // traverse until the queue is empty        while (q.length != 0) {          var size = q.length;          level += 1;           // traverse for complete level          while (size > 0) {            var temp = q[0];            q.shift();             // check if the node is leaf node and            // level is odd if level is odd,            // then update result            if (temp.left == null && temp.right == null &&            level % 2 != 0) {              result = level;            }             // check for left child            if (temp.left != null) {              q.push(temp.left);            }             // check for right child            if (temp.right != null) {              q.push(temp.right);            }            size -= 1;          }        }        return result;      }       // Driver Code      // construct a tree      var 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);      root.right.right.right.right.left = newNode(11);       var result = maxOddLevelDepth(root);       if (result == 2147483647)      document.write("No leaf node at odd level");      else {        document.write(result);        document.write(" is the required depth");      }       </script>
Output: 
5 is the required depth
Time Complexity: Time Complexity is O(n). 
YouTubeGeeksforGeeks502K subscribersFind depth of the deepest odd level leaf node | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 3:35•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=bPp5bjjXhhQ" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Chandra Prakash. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
shrikanth13
SHUBHAMSINGH10
Akanksha_Rai
Rajput-Ji
princiraj1992
rdtank
amartyaghoshgfg
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Construct Tree from given Inorder and Preorder traversals
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
BFS vs DFS for Binary Tree
Expression Tree
Sorted Array to Balanced BST