Check if all leaves are at same level - GeeksforGeeks

03 Nov, 2021
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
 
The idea is to first find the 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 a 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++
C
Java
Python
C#
Javascript
// C++ program to check if all leaves// are at same level#include <bits/stdc++.h>using namespace std; // 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;} /* Recursive function which checks whetherall 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 checkif 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 Codeint 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
// C program to check if all leaves are at same level#include <stdio.h>#include <stdlib.h> // 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;} /* 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 functionint 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;}
// Java program to check if all leaves are at same level  // A binary tree nodeclass 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
# Python program to check if all leaves are at same level # A binary tree nodeclass 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 leveldef 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 functionroot = 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)
// C# program to check if all leaves// are at same levelusing System; // A binary tree nodepublic 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 checkswhether 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 leafsare at same level. It mainly uses checkUtil() */public virtual bool check(Node node){    int level = 0;    return checkUtil(node, level, mylevel);} // Driver Codepublic 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
<script> // Javascript program to check if all// leaves are at same level   // A binary tree nodeclass Node{    constructor(item)    {        this.data = item;        this.left = this.right = null;    }}class Leaf{    leaflevel = 0;} let root;let mylevel = new Leaf(); // Recursive function which checks// whether all leaves are at same levelfunction checkUtil(node, level, 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()function check(node){    let level = 0;    return checkUtil(node, level, mylevel);} // Driver code // Let us create the tree as shown in the exampleroot = new Node(12);root.left = new Node(5);root.left.left = new Node(3);root.left.right = new Node(9);root.left.left.left = new Node(1);root.left.right.left = new Node(1); if (check(root))    document.write("Leaves are at same level");else    document.write("Leaves are not at same level"); // This code is contributed by rag2127 </script>
Output: 
Leaves are at same level
Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).  
Method 2 (Iterative)
It can also be solved by an iterative approach.The idea is to iteratively traverse the tree, and when you encounter the first leaf node, store its level in result variable, now whenever you encounter any leaf node, compare its level with previously stored result, they are the same then proceed for the rest of tree, else return false.
C++
Java
Python3
C#
Javascript
// C++ program to check if all leaf nodes are at// same level 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 true if all leaf nodes are// at same level, else falseint 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 programint 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;}
// Java program to check if all leaf nodes are at // same level of binary treeimport java.util.*; // User defined node classclass 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
# Python3 program to check if all leaf nodes# are at same level of binary treeINT_MAX = 2**31INT_MIN = -2**31 # Tree Node# returns a new tree Nodeclass newNode:    def __init__(self, data):        self.data = data        self.left = self.right = None         # return true if all leaf nodes are# at same level, else falsedef 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 Codeif __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
// C# program to check if all leaf nodes are at// same level of binary treeusing System;using System.Collections.Generic; // User defined node classpublic 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
<script> // Javascript program to check if all// leaf nodes are at same level of binary tree // User defined node classclass Node{         // Constructor to create a new tree node    constructor(key)    {        this.data = key;        this.left = this.right = null;    }} // Return true if all leaf nodes are// at same level, else falsefunction checkLevelLeafNode(root){    if (root == null)     return true;         // Create a queue for level    // order traversal    let q = [];    q.push(root);         let result = Number.MAX_VALUE;    let level = 0;         // Traverse until the queue is empty    while (q.length != 0)    {        let size = q.length;        level++;                 // traverse for complete level        while (size > 0)        {            let temp = q.shift();             // check for left child            if (temp.left != null)            {                q.push(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 == Number.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.push(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 == Number.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 // construct a treelet 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); let result = checkLevelLeafNode(root);if (result == true)    document.write("All leaf nodes are at same level");else    document.write("Leaf nodes not at same level");   // This code is contributed by avanitrachhadiya2155 </script>
Output: 
All leaf nodes are at same level
Time Complexity : O(n)This code is contributed by – Mandeep Singh 
YouTubeGeeksforGeeks502K subscribersCheck if all leaves are at same level | 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:34•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=K5ifmmXjwOg" 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. 
msdeep14
shrikanth13
rachana soma
SHUBHAMSINGH10
Akanksha_Rai
29AjayKumar
nobody_cares
prabhatkumarsharma
rag2127
avanitrachhadiya2155
surindertarika1234
harshchandekar10
Amazon
Tree
Amazon
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Decision Tree
Construct Tree from given Inorder and Preorder traversals
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
Expression Tree
BFS vs DFS for Binary Tree
Sorted Array to Balanced BST
Relationship between number of nodes and height of binary tree
Binary Tree (Array implementation)