Check if all leaves are at same level

Given a Binary Tree, check if all leaves are at same level or not.

          12
        /    \
      5       7       
    /          \ 
   3            1
  Leaves are at same level

          12
        /    \
      5       7       
    /          
   3          
   Leaves are Not at same level


          12
        /    
      5             
    /   \        
   3     9
  /      /
 1      2
 Leaves are at same level


Method 1 (Recursive)

The idea is to first find level of the leftmost leaf and store it in a variable leafLevel. Then compare level of all other leaves with leafLevel, if same, return true, else return false. We traverse the given Binary Tree in Preorder fashion. An argument leaflevel is passed to all calls. The value of leafLevel is initialized as 0 to indicate that the first leaf is not yet seen yet. The value is updated when we find first leaf. Level of subsequent leaves (in preorder) is compared with leafLevel.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if all leaves
// are at same level
#include <bits/stdc++.h>
using namespace std;
  
// A binary tree node
struct Node
{
    int data;
    struct Node *left, *right;
};
  
// A utility function to allocate 
// a new tree node
struct Node* newNode(int data)
{
    struct Node* node = (struct Node*) malloc(sizeof(struct Node));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}
  
/* Recursive function which checks whether
all leaves are at same level */
bool checkUtil(struct Node *root, 
            int level, int *leafLevel)
{
    // Base case
    if (root == NULL) return true;
  
    // If a leaf node is encountered
    if (root->left == NULL && 
        root->right == NULL)
    {
        // When a leaf node is found 
        // first time
        if (*leafLevel == 0)
        {
            *leafLevel = level; // Set first found leaf's level
            return true;
        }
  
        // If this is not first leaf node, compare 
        // its level with first leaf's level
        return (level == *leafLevel);
    }
  
    // If this node is not leaf, recursively
    // check left and right subtrees
    return checkUtil(root->left, level + 1, leafLevel) &&
            checkUtil(root->right, level + 1, leafLevel);
}
  
/* The main function to check 
if all leafs are at same level.
It mainly uses checkUtil() */
bool check(struct Node *root)
{
    int level = 0, leafLevel = 0;
    return checkUtil(root, level, &leafLevel);
}
  
// Driver Code
int main()
{
    // Let us create tree shown in third example
    struct Node *root = newNode(12);
    root->left = newNode(5);
    root->left->left = newNode(3);
    root->left->right = newNode(9);
    root->left->left->left = newNode(1);
    root->left->right->left = newNode(1);
    if (check(root))
        cout << "Leaves are at same level\n";
    else
        cout << "Leaves are not at same level\n";
    getchar();
    return 0;
}
  
// This code is contributed
// by Akanksha Rai

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to check if all leaves are at same level
#include <stdio.h>
#include <stdlib.h>
  
// A binary tree node
struct Node
{
    int data;
    struct Node *left, *right;
};
  
// A utility function to allocate a new tree node
struct Node* newNode(int data)
{
    struct Node* node = (struct Node*) malloc(sizeof(struct Node));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}
  
/* Recursive function which checks whether all leaves are at same level */
bool checkUtil(struct Node *root, int level, int *leafLevel)
{
    // Base case
    if (root == NULL)  return true;
  
    // If a leaf node is encountered
    if (root->left == NULL && root->right == NULL)
    {
        // When a leaf node is found first time
        if (*leafLevel == 0)
        {
            *leafLevel = level; // Set first found leaf's level
            return true;
        }
  
        // If this is not first leaf node, compare its level with
        // first leaf's level
        return (level == *leafLevel);
    }
  
    // If this node is not leaf, recursively check left and right subtrees
    return checkUtil(root->left, level+1, leafLevel) &&
           checkUtil(root->right, level+1, leafLevel);
}
  
/* The main function to check if all leafs are at same level.
   It mainly uses checkUtil() */
bool check(struct Node *root)
{
   int level = 0, leafLevel = 0;
   return checkUtil(root, level, &leafLevel);
}
  
// Driver program to test above function
int main()
{
    // Let us create tree shown in thirdt example
    struct Node *root = newNode(12);
    root->left = newNode(5);
    root->left->left = newNode(3);
    root->left->right = newNode(9);
    root->left->left->left = newNode(1);
    root->left->right->left = newNode(1);
    if (check(root))
        printf("Leaves are at same level\n");
    else
        printf("Leaves are not at same level\n");
    getchar();
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to check if all leaves are at same level
   
// A binary tree node
class Node 
{
    int data;
    Node left, right;
   
    Node(int item) 
    {
        data = item;
        left = right = null;
    }
}
   
class Leaf 
{
    int leaflevel=0;
}
   
class BinaryTree 
{
    Node root;
    Leaf mylevel = new Leaf();
      
    /* Recursive function which checks whether all leaves are at same 
       level */
    boolean checkUtil(Node node, int level, Leaf leafLevel) 
    {
        // Base case
        if (node == null)
            return true;
              
        // If a leaf node is encountered
        if (node.left == null && node.right == null
        {
            // When a leaf node is found first time
            if (leafLevel.leaflevel == 0
            {
                // Set first found leaf's level
                leafLevel.leaflevel = level; 
                return true;
            }
   
            // If this is not first leaf node, compare its level with
            // first leaf's level
            return (level == leafLevel.leaflevel);
        }
   
        // If this node is not leaf, recursively check left and right 
        // subtrees
        return checkUtil(node.left, level + 1, leafLevel)
                && checkUtil(node.right, level + 1, leafLevel);
    }
   
    /* The main function to check if all leafs are at same level.
       It mainly uses checkUtil() */
    boolean check(Node node) 
    {
        int level = 0;
        return checkUtil(node, level, mylevel);
    }
   
    public static void main(String args[]) 
    {
        // Let us create the tree as shown in the example
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(12);
        tree.root.left = new Node(5);
        tree.root.left.left = new Node(3);
        tree.root.left.right = new Node(9);
        tree.root.left.left.left = new Node(1);
        tree.root.left.right.left = new Node(1);
        if (tree.check(tree.root))
            System.out.println("Leaves are at same level");
        else
            System.out.println("Leaves are not at same level");
    }
}
   
// This code has been contributed by Mayank Jaiswal

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to check if all leaves are at same level
  
# A binary tree node
class Node:
      
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
  
# Recursive function which check whether all leaves are at
# same level
def checkUtil(root, level):
      
    # Base Case 
    if root is None:
        return True
      
    # If a tree node is encountered
    if root.left is None and root.right is None:
          
        # When a leaf node is found first time
        if check.leafLevel == 0 :
            check.leafLevel = level # Set first leaf found
            return True
  
        # If this is not first leaf node, compare its level
        # with first leaf's level
        return level == check.leafLevel 
  
    # If this is not first leaf node, compare its level
    # with first leaf's level
    return (checkUtil(root.left, level+1)and
            checkUtil(root.right, level+1))
  
def check(root):
    level = 0
    check.leafLevel = 0 
    return (checkUtil(root, level))
  
# Driver program to test above function
root = Node(12)
root.left = Node(5)
root.left.left = Node(3)
root.left.right = Node(9)
root.left.left.left = Node(1)
root.left.right.left = Node(2)
  
if(check(root)):
    print "Leaves are at same level"
else:
    print "Leaves are not at same level"
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to check if all leaves 
// are at same level 
using System;
  
// A binary tree node 
public class Node
{
    public int data;
    public Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
public class Leaf
{
    public int leaflevel = 0;
}
  
class GFG
{
public Node root;
public Leaf mylevel = new Leaf();
  
/* Recursive function which checks 
whether all leaves are at same level */
public virtual bool checkUtil(Node node, int level,
                              Leaf leafLevel)
{
    // Base case 
    if (node == null)
    {
        return true;
    }
  
    // If a leaf node is encountered 
    if (node.left == null && node.right == null)
    {
        // When a leaf node is found first time 
        if (leafLevel.leaflevel == 0)
        {
            // Set first found leaf's level 
            leafLevel.leaflevel = level;
            return true;
        }
  
        // If this is not first leaf node, 
        // compare its level with first leaf's level 
        return (level == leafLevel.leaflevel);
    }
  
    // If this node is not leaf, recursively 
    // check left and right subtrees 
    return checkUtil(node.left, level + 1, leafLevel) && 
           checkUtil(node.right, level + 1, leafLevel);
}
  
/* The main function to check if all leafs 
are at same level. It mainly uses checkUtil() */
public virtual bool check(Node node)
{
    int level = 0;
    return checkUtil(node, level, mylevel);
}
  
// Driver Code
public static void Main(string[] args)
{
    // Let us create the tree as shown in the example 
    GFG tree = new GFG();
    tree.root = new Node(12);
    tree.root.left = new Node(5);
    tree.root.left.left = new Node(3);
    tree.root.left.right = new Node(9);
    tree.root.left.left.left = new Node(1);
    tree.root.left.right.left = new Node(1);
    if (tree.check(tree.root))
    {
        Console.WriteLine("Leaves are at same level");
    }
    else
    {
        Console.WriteLine("Leaves are not at same level");
    }
}
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

Leaves are at same level

Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).

 

Method 1 (Iterative)

It can also be solved by iterative approach.

The idea is to iteratively traverse the tree, and when you encounter the first leaf node, store it’s level in result variable, now whenever you encounter any leaf node, compare it’s level with previously stored result, it they are same then proceed for rest of the tree, else return false.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to check if all leaf nodes are at 
// same level 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 true if all leaf nodes are
// at same level, else false
int checkLevelLeafNode(Node* root)
{
    if (!root)
        return 1;
   
    // 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 for left child
            if (temp->left) {
                q.push(temp->left);
  
                // if its leaf node
                if(!temp->left->right && !temp->left->left){
  
                    // if it's first leaf node, then update result
                    if (result == INT_MAX)
                        result = level;
                      
                    // if it's not first leaf node, then compare 
                    // the level with level of previous leaf node
                    else if (result != level)
                        return 0;                    
                }
            }
               
             // check for right child
            if (temp->right){
                q.push(temp->right);
  
                // if it's leaf node
                if (!temp->right->left && !temp->right->right)
  
                    // if it's first leaf node till now, 
                    // then update the result
                    if (result == INT_MAX)
                        result = level;
                      
                    // if it is not the first leaf node, 
                    // then compare the level with level 
                    // of previous leaf node
                    else if(result != level)
                        return 0;
                      
               }
               size -= 1;
        }    
    }
      
    return 1;
}
   
// 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);
   
    int result = checkLevelLeafNode(root);
    if (result)
        cout << "All leaf nodes are at same level\n";
    else
        cout << "Leaf nodes not at same level\n";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to check if all leaf nodes are at  
// same level of binary tree
import java.util.*;
  
// User defined node class
class Node {
      int data;
      Node left, right;
        
      // Constructor to create a new tree node
      Node(int key) {
           int data = key;
           left = right = null;
      }
}
  
class GFG {
  
      // return true if all leaf nodes are 
      // at same level, else false 
      static boolean checkLevelLeafNode(Node root)
      {
             if (root == null)
                 return true;
  
             // 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.size() != 0) {
                    int size = q.size();
                    level++;
  
                    // traverse for complete level
                    while (size > 0) {
                         Node temp = q.remove();
  
                         // check for left child
                         if (temp.left != null) {
                             q.add(temp.left);
  
                              // if its leaf node
                              if (temp.left.left != null && temp.left.right != null) {
                                   
                                  // if it's first leaf node, then update result
                                  if (result == Integer.MAX_VALUE)
                                      result = level;
  
                                  // if it's not first leaf node, then compare  
                                  // the level with level of previous leaf node.
                                  else if (result != level)
                                       return false
                              }
                         }
                           
                          // check for right child 
                          if (temp.right != null) {
                             q.add(temp.right);
  
                              // if its leaf node
                             if (temp.right.left != null && temp.right.right != null) {
                                   
                                  // if it's first leaf node, then update result
                                  if (result == Integer.MAX_VALUE)
                                      result = level;
  
                                  // if it's not first leaf node, then compare  
                                  // the level with level of previous leaf node.
                                  else if (result != level)
                                       return false
                              }
                         }
                         size--;
                    }
  
             }
             return true;
      }
  
      // Driver code
      public static void main(String args[])
      {
             // construct a tree 
             Node root = new Node(1);
             root.left = new Node(2);
             root.right = new Node(3);
             root.left.right = new Node(4);
             root.right.left = new Node(5);
             root.right.right = new Node(6);
  
             boolean result = checkLevelLeafNode(root);
             if (result == true)
                 System.out.println("All leaf nodes are at same level");
             else
                 System.out.println("Leaf nodes not at same level");  
      }
}
// This code is contributed by rachana soma

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to check if all leaf nodes 
# are at same level of binary tree 
INT_MAX = 2**31
INT_MIN = -2**31
  
# Tree Node
# returns a new tree Node
class newNode: 
    def __init__(self, data): 
        self.data = data 
        self.left = self.right = None
          
# return true if all leaf nodes are 
# at same level, else false 
def checkLevelLeafNode(root) :
  
    if (not root) :
        return 1
      
    # 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 or len(q)): 
            temp = q[0
            q.pop(0
          
            # check for left child 
            if (temp.left) :
                q.append(temp.left) 
  
                # if its leaf node 
                if(not temp.left.right and 
                   not temp.left.left): 
  
                    # if it's first leaf node, 
                    # then update result 
                    if (result == INT_MAX):
                        result = level 
                      
                    # if it's not first leaf node, 
                    # then compare the level with
                    # level of previous leaf node 
                    elif (result != level): 
                        return 0                    
                  
            # check for right child 
            if (temp.right) :
                q.append(temp.right) 
  
                # if it's leaf node 
                if (not temp.right.left and 
                    not temp.right.right): 
  
                    # if it's first leaf node till now, 
                    # then update the result 
                    if (result == INT_MAX): 
                        result = level 
                      
                    # if it is not the first leaf node, 
                    # then compare the level with level 
                    # of previous leaf node 
                    elif(result != level): 
                        return 0
                size -= 1
    return 1
  
# Driver Code 
if __name__ == '__main__':
      
    # construct a 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
      
    result = checkLevelLeafNode(root) 
    if (result) :
        print("All leaf nodes are at same level")
    else:
        print("Leaf nodes not at same level")
  
# This code is contributed by SHUBHAMSINGH10

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to check if all leaf nodes are at 
// same level of binary tree 
using System;
using System.Collections.Generic;
  
// User defined node class 
public class Node
    public int data; 
    public Node left, right; 
          
    // Constructor to create a new tree node 
    public Node(int key) 
    
        int data = key; 
        left = right = null
    
  
public class GFG 
  
    // return true if all leaf nodes are 
    // at same level, else false 
    static bool checkLevelLeafNode(Node root) 
    
            if (root == null
                return true
  
            // 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++; 
  
                    // traverse for complete level 
                    while (size > 0)
                    
                        Node temp = q.Dequeue(); 
  
                        // check for left child 
                        if (temp.left != null
                        
                            q.Enqueue(temp.left); 
  
                            // if its leaf node 
                            if (temp.left.left != null && 
                                temp.left.right != null)
                            
                                  
                                // if it's first leaf node, then update result 
                                if (result == int.MaxValue) 
                                    result = level; 
  
                                // if it's not first leaf node, then compare 
                                // the level with level of previous leaf node. 
                                else if (result != level) 
                                    return false
                            
                        
                          
                        // check for right child 
                        if (temp.right != null)
                        
                            q.Enqueue(temp.right); 
  
                            // if its leaf node 
                            if (temp.right.left != null && 
                                temp.right.right != null
                            
                                  
                                // if it's first leaf node, then update result 
                                if (result == int.MaxValue) 
                                    result = level; 
  
                                // if it's not first leaf node, then compare 
                                // the level with level of previous leaf node. 
                                else if (result != level) 
                                    return false
                            
                        
                        size--; 
                    
            
            return true
    
  
    // Driver code 
    public static void Main(String []args) 
    
        // construct a tree 
        Node root = new Node(1); 
        root.left = new Node(2); 
        root.right = new Node(3); 
        root.left.right = new Node(4); 
        root.right.left = new Node(5); 
        root.right.right = new Node(6); 
  
        bool result = checkLevelLeafNode(root); 
        if (result == true
            Console.WriteLine("All leaf nodes are at same level"); 
        else
            Console.WriteLine("Leaf nodes not at same level"); 
    
  
// This code has been contributed by 29AjayKumar

chevron_right



Output:

All leaf nodes are at same level

Time Complexity : O(n)

This code is contributed by Mandeep Singh

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.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.