Related Articles

Related Articles

Height of binary tree considering even level leaves only
  • Difficulty Level : Hard
  • Last Updated : 03 Nov, 2020

Find the height of the binary tree given that only the nodes on the even levels are considered as the valid leaf nodes.
The height of a binary tree is the number of edges between the tree’s root and its furthest leaf. But what if we bring a twist and change the definition of a leaf node. Let us define a valid leaf node as the node that has no children and is at an even level (considering root node as an odd level node).

Output :Height of tree is 4

Solution : The approach to this problem is slightly different from the normal height finding approach. In the return step, we check if the node is a valid root node or not. If it is valid, return 1, else we return 0. Now in the recursive step- if the left and the right sub-tree both yield 0, the current node yields 0 too, because in that case there is no path from current node to a valid leaf node. But in case at least one of the values returned by the children is non-zero, it means the leaf node on that path is a valid leaf node, and hence that path can contribute to the final result, so we return max of the values returned + 1 for the current node.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* Program to find height of the tree considering
   only even level leaves. */
#include <bits/stdc++.h>
using namespace std;
  
/* A binary tree node has data, pointer to
   left child and a pointer to right child */
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
  
int heightOfTreeUtil(Node* root, bool isEven)
{
    // Base Case
    if (!root)
        return 0;
  
    if (!root->left && !root->right) {
        if (isEven)
            return 1;
        else
            return 0;
    }
  
    /*left stores the result of left subtree,
      and right stores the result of right subtree*/
    int left = heightOfTreeUtil(root->left, !isEven);
    int right = heightOfTreeUtil(root->right, !isEven);
  
    /*If both left and right returns 0, it means
      there is no valid path till leaf node*/
    if (left == 0 && right == 0)
        return 0;
  
    return (1 + max(left, right));
}
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct Node* newNode(int data)
{
    struct Node* node = 
              (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
  
    return (node);
}
  
int heightOfTree(Node* root)
{
    return heightOfTreeUtil(root, false);
}
  
/* Driver program to test above functions*/
int main()
{
    // Let us create binary tree shown in above diagram
    struct Node* root = newNode(1);
  
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->left->right->left = newNode(6);
    cout << "Height of tree is " << heightOfTree(root);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

/* Java Program to find height of the tree considering 
only even level leaves. */
class GfG {
  
/* A binary tree node has data, pointer to 
left child and a pointer to right child */
static class Node { 
    int data; 
    Node left; 
 Node right; 
}
  
static int heightOfTreeUtil(Node root, boolean isEven) 
    // Base Case 
    if (root == null
        return 0
  
    if (root.left == null && root.right == null) { 
        if (isEven == true
            return 1
        else
            return 0
    
  
    /*left stores the result of left subtree, 
    and right stores the result of right subtree*/
    int left = heightOfTreeUtil(root.left, !isEven); 
    int right = heightOfTreeUtil(root.right, !isEven); 
  
    /*If both left and right returns 0, it means 
    there is no valid path till leaf node*/
    if (left == 0 && right == 0
        return 0
  
    return (1 + Math.max(left, right)); 
  
/* Helper function that allocates a new node with the 
given data and NULL left and right pointers. */
static Node newNode(int data) 
    Node node = new Node(); 
    node.data = data; 
    node.left = null
    node.right = null
  
    return (node); 
  
static int heightOfTree(Node root) 
    return heightOfTreeUtil(root, false); 
  
/* Driver program to test above functions*/
public static void main(String[] args) 
    // Let us create binary tree shown in above diagram 
    Node root = newNode(1); 
  
    root.left = newNode(2); 
    root.right = newNode(3); 
    root.left.left = newNode(4); 
    root.left.right = newNode(5); 
    root.left.right.left = newNode(6); 
    System.out.println("Height of tree is " + heightOfTree(root)); 
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Program to find height of the tree considering 
# only even level leaves.
  
# Helper class that allocates a new node with the 
# given data and None left and right pointers. 
class newNode:
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
  
def heightOfTreeUtil(root, isEven):
      
    # Base Case 
    if (not root): 
        return 0
  
    if (not root.left and not root.right): 
        if (isEven): 
            return 1
        else:
            return 0
  
    # left stores the result of left subtree, 
    # and right stores the result of right subtree
    left = heightOfTreeUtil(root.left, not isEven) 
    right = heightOfTreeUtil(root.right, not isEven) 
  
    #If both left and right returns 0, it means 
    # there is no valid path till leaf node
    if (left == 0 and right == 0):
        return 0
  
    return (1 + max(left, right))
  
def heightOfTree(root):
    return heightOfTreeUtil(root, False)
  
# Driver Code
if __name__ == '__main__'
      
    # Let us create binary tree shown
    # in above diagram 
    root = newNode(1
  
    root.left = newNode(2
    root.right = newNode(3
    root.left.left = newNode(4
    root.left.right = newNode(5
    root.left.right.left = newNode(6
    print("Height of tree is",
           heightOfTree(root))
  
# This code is contributed by PranchalK

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

/* C# Program to find height of the tree considering 
only even level leaves. */
using System;
  
class GfG
  
    /* A binary tree node has data, pointer to 
    left child and a pointer to right child */
    class Node
    
        public int data; 
        public Node left; 
        public Node right; 
    
  
    static int heightOfTreeUtil(Node root,
                               bool isEven) 
    
        // Base Case 
        if (root == null
            return 0; 
  
        if (root.left == null && 
            root.right == null)
        
            if (isEven == true
                return 1; 
            else
                return 0; 
        
  
        /*left stores the result of left subtree, 
        and right stores the result of right subtree*/
        int left = heightOfTreeUtil(root.left, !isEven); 
        int right = heightOfTreeUtil(root.right, !isEven); 
  
        /*If both left and right returns 0, it means 
        there is no valid path till leaf node*/
        if (left == 0 && right == 0) 
            return 0; 
  
        return (1 + Math.Max(left, right)); 
    
  
    /* Helper function that allocates a new node with the 
    given data and NULL left and right pointers. */
    static Node newNode(int data) 
    
        Node node = new Node(); 
        node.data = data; 
        node.left = null
        node.right = null
  
        return (node); 
    
  
    static int heightOfTree(Node root) 
    
        return heightOfTreeUtil(root, false); 
    
  
    /* Driver code*/
    public static void Main(String[] args) 
    
        // Let us create binary tree
        // shown in above diagram 
        Node root = newNode(1); 
  
        root.left = newNode(2); 
        root.right = newNode(3); 
        root.left.left = newNode(4); 
        root.left.right = newNode(5); 
        root.left.right.left = newNode(6); 
        Console.WriteLine("Height of tree is " +
                            heightOfTree(root)); 
    
  
/* This code is contributed by Rajput-Ji*/

chevron_right



Output:

Height of tree is 4

Time Complexity:O(n) where n is number of nodes in given binary tree.

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :