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
 

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.

Algorithm:

1.Define a function named checkUtil which takes in three arguments:

   *A node of the binary tree.
   *An integer level which represents the depth of the current node in the tree.
   *A Leaf object named leafLevel which stores the level of the first leaf node found.
2.Check if the current node is null. If it is, return true.

3.Check if the current node is a leaf node by verifying that both its left and right children are null. If the node is a leaf:

   *If it’s the first leaf node found, set the level of the first leaf node to the current level and return true.
   *If it’s not the first leaf node found, compare its level to the level of the first leaf node found. Return true if they’re equal, false otherwise.
4.If the current node is not a leaf, recursively call checkUtil on its left and right children, incrementing the level by 1 for each call. Return true if both calls return true.

5.Define a function named check which takes in a single argument: a node of the binary tree.

6.Initialize the level variable to 0.

7.Create a Leaf object named mylevel which will store the level of the first leaf node found.

8.Call checkUtil on the root node of the tree, passing in the level, mylevel, and the root node.

9.Return the result of the checkUtil call. This will be true if all leaf nodes are at the same level, false otherwise.

Implementation:

C++

// 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

C

// 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 check(struct Node *root)
{
   int level = 0, leafLevel = 0;
   return checkUtil(root, level, &leafLevel);
}
bool checkUtil(struct Node *root, int level, int *leafLevel)
{
    // Base case
    if (root == NULL)  return 1;

    // 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() */


// 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;
}

Java

// 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

Python

# 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)

C#

// 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

Javascript

<script>

// Javascript program to check if all
// leaves are at same level

// A binary tree node
class 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 level
function 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 example
root = 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).
Auxiliary Space: O(H) for call stack, where H is height of tree

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.

Implementation:

C++

// C++ 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 flag = 0;

    // traverse until the queue is empty
    while (!q.empty()) {
        int n = q.size();

        // traverse for complete level
        for (int i = 1; i <= n; i++) {
            Node* temp = q.front();
            q.pop();

            // check for left child
            if (temp->left) {
                q.push(temp->left);
            }

            // check for right child
            if (temp->right) {
                q.push(temp->right);
            }

            // check for leaf node
            if (temp->left == NULL && temp->right == NULL)
                flag = 1;
        }

        // check if there exist any further levels.
        if (flag && !q.empty())
            return 0;
    }

    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;
}

Java

// 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

Python3

# 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

C#

// 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

Javascript

<script>

// Javascript program to check if all
// leaf nodes are at same level of binary tree

// User defined node class
class 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 false
function 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 tree
let 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)
Auxiliary Space: O(n)

Method 3 :  One point to note down is that if all the leaf nodes are at the same level then the distance of all the leaf nodes from the root node will be the same. Now, assume that there are two leaf nodes leafA and leafB at distance distA and distB respectively from the root node. Here distA < distB. The node leaf A is closer to the root than leafB.

Now, suppose max_dist and min_dist represent the maximum distance and minimum distance out of all the distances of all the leaf nodes from the root node. Now in the above situation of the leaf nodes leafA and leafB, max_dist will not be equal to min_dist because distA < distB. So we can also say that if max_dist is equal to min_dist then all the leaf nodes are at same level else the leaf nodes are not at the same level.

So we will find max_dist and min_dist for a given binary tree. If max_dist is equal to min_dist then all the leaf nodes are at the same level else the leaf nodes are not at the same level.

Algorithm :

1) Finding the max_dist is similar to finding the height of the given tree. You can read the following article for the solution

https://www.geeksforgeeks.org/find-the-maximum-depth-or-height-of-a-tree/

2)The approach for finding min_dist will be almost similar to finding max_dist.We will use a recursive approach

3) Now for finding the min_dist, assume a function minDist() which takes root node as input and returns min_dist.

4) Now the given node will ask for the minimum distance from its adjacent left node of the left subtree say left_dist  and the minimum distance from its adjacent right node of the right subtree say right_dist.

5) Now there are basically 4 types of node

5.1) If a node has left and right node as null, then it will return 1

5.2) If a node has the left node as null, then it will ignore the left null node. We can assume that the left node is at a distance of infinity. Here left_dist will be infinity.

5.3) If a node has the right node as null, then it will ignore the right null node. We can assume that the right node is at a distance of infinity. Here right_dist will be infinity.

5.4) If a node has both right and left nodes then it will get the left_dist and right_dist.

6) Now after getting the right_dist and left_dist the given node will return min( right_dist , left_dist) + 1. Here we are taking a minimum of left_dist and right_dist because we have to find the minimum distance of the leaf node from the root. We are adding 1 because the current node also needs to be counted.

Now after getting max_dist and min_dist, if they are equal we will return true. If they are not equal we will return false.

Implementation :

C++

/*package whatever //do not write package name here */
#include <bits/stdc++.h>

using namespace std;

class Node {
public:
    int data;
    Node *left, *right;

    Node(int item)
    {
        data = item;
        left = right = NULL;
    }
};

int maxDist(Node* curr)
{

    // if node curr is null then return 0

    if (curr == NULL)
        return 0;

    // call for maximum height of left subtree

    int left_dist = maxDist(curr->left);

    // call for maximum height of right subtree

    int right_dist = maxDist(curr->right);

    // we are taking max(left_dist , right_dist) because we
    // need to find the maximum height
    // adding  1 to the max(left_dist , right_dist) of them
    // as current node also need to be counted

    return 1 + max(left_dist, right_dist);
}

int minDist(Node* curr)
{

    // if the node curr is null than we can assume that it
    // is at distance infinity(Integer.MAX_VALUE)
    // as we have to find the maximum height
    if (curr == NULL)
        return INT_MAX;

    // if the node curr is leaf node then simply return 1
    if (curr->left == NULL && curr->right == NULL)
        return 1;

    // call for minimum height of left subtree

    int left_dist = minDist(curr->left);

    // call for minimum height of right subtree

    int right_dist = minDist(curr->right);
    // we are taking min(left_dist , right_dist) because we
    // need to find the minimum height

    // add 1 to the min(left_dist , right_dist) of them as
    // current node also need to be counted

    return 1 + min(left_dist, right_dist);
}
int main()
{

    Node* root = 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);

    // calling maxDist() function to get maximum height

    int max_dist = maxDist(root);

    // calling minDist() function to get maximum height

    int min_dist = minDist(root);

    // comparing both the distances

    if (max_dist == min_dist)
        cout << "Leaves are at same level" << endl;
    else
        cout << "Leaves are not at same level" << endl;
}

Java

/*package whatever //do not write package name here */

import java.io.*;
class Node {
    int data;
    Node left, right;

    Node(int item)
    {
        data = item;
        left = right = null;
    }
}

public class GFG {

    public static void main(String[] args)
    {

        Node root = 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);

        // calling maxDist() function to get maximum height

        int max_dist = maxDist(root);

        // calling minDist() function to get maximum height

        int min_dist = minDist(root);

        // comparing both the distances

        if (max_dist == min_dist)
            System.out.println("Leaves are at same level");
        else
            System.out.println(
                "Leaves are not at same level");
    }

    static int maxDist(Node curr)
    {

        // if node curr is null then return 0

        if (curr == null)
            return 0;

        // call for maximum height of left subtree

        int left_dist = maxDist(curr.left);

        // call for maximum height of right subtree

        int right_dist = maxDist(curr.right);

        // we are taking max(left_dist , right_dist) because
        // we need to find the maximum height
        // adding  1 to the max(left_dist , right_dist) of
        // them as current node also need to be counted

        return 1 + Math.max(left_dist, right_dist);
    }

    static int minDist(Node curr)
    {

        // if the node curr is null than we can assume that
        // it is at distance infinity(Integer.MAX_VALUE)
        // as we have to find the maximum height
        if (curr == null)
            return Integer.MAX_VALUE;

        // if the node curr is leaf node then simply return
        // 1
        if (curr.left == null && curr.right == null)
            return 1;

        // call for minimum height of left subtree

        int left_dist = minDist(curr.left);

        // call for minimum height of right subtree

        int right_dist = minDist(curr.right);
        // we are taking min(left_dist , right_dist) because
        // we need to find the minimum height

        // add 1 to the min(left_dist , right_dist) of them
        // as current node also need to be counted

        return 1 + Math.min(left_dist, right_dist);
    }
}

Python3

import sys


class Node:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right


def maxDist(curr):
    # if node curr is null then return 0
    if(curr == None):
        return 0

    # call for maximum height of left subtree
    left_dist = maxDist(curr.left)

    # call for maximum height of right subtree
    right_dist = maxDist(curr.right)
    '''we are taking max(left_dist , right_dist) because we need to find the maximum height
     adding  1 to the max(left_dist , right_dist) of them as current node also need to be counted '''
    return 1 + max(left_dist, right_dist)


def minDist(curr):
    # if the node curr is null than we can assume that it is at distance infinity(Integer.MAX_VALUE)
    # as we have to find the maximum height
    if (curr == None):
        return sys.maxsize
    # if the node curr is leaf node then simply return 1
    if ((curr.left == None) and (curr.right == None)):
        return 1
    # call for minimum height of left subtree

    left_dist = minDist(curr.left)

    # call for minimum height of right subtree

    right_dist = minDist(curr.right)

    # we are taking min(left_dist , right_dist) because we need to find the minimum height
    # add 1 to the min(left_dist , right_dist) of them as current node also need to be counted

    return 1 + min(left_dist, right_dist)


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(1)

# calling maxDist() function to get maximum height

maxDist = maxDist(root)

# calling minDist() function to get minimum height

min_dist = minDist(root)

# comparing both the distances

if maxDist == minDist:
    print('leaves are at same level')
else:
    print('Leaves are not at same level')

C#

using System;

class Node
{
  public int data;
  public Node left, right;

  public Node(int item)
  {
    data = item;
    left = right = null;
  }
}

class Program
{
  static int maxDist(Node curr)
  {
    // if node curr is null then return 0
    if (curr == null)
      return 0;

    // call for maximum height of left subtree
    int left_dist = maxDist(curr.left);

    // call for maximum height of right subtree
    int right_dist = maxDist(curr.right);

    // we are taking max(left_dist , right_dist) because we
    // need to find the maximum height
    // adding  1 to the max(left_dist , right_dist) of them
    // as current node also need to be counted
    return 1 + Math.Max(left_dist, right_dist);
  }

  static int minDist(Node curr)
  {
    // if the node curr is null than we can assume that it
    // is at distance infinity(Integer.MAX_VALUE)
    // as we have to find the maximum height
    if (curr == null)
      return Int32.MaxValue;

    // if the node curr is leaf node then simply return 1
    if (curr.left == null && curr.right == null)
      return 1;

    // call for minimum height of left subtree
    int left_dist = minDist(curr.left);

    // call for minimum height of right subtree
    int right_dist = minDist(curr.right);

    // we are taking min(left_dist , right_dist) because we
    // need to find the minimum height

    // add 1 to the min(left_dist , right_dist) of them as
    // current node also need to be counted
    return 1 + Math.Min(left_dist, right_dist);
  }

  static void Main(string[] args)
  {
    Node root = 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);

    // calling maxDist() function to get maximum height
    int max_dist = maxDist(root);

    // calling minDist() function to get maximum height
    int min_dist = minDist(root);

    // comparing both the distances
    if (max_dist == min_dist)
      Console.WriteLine("Leaves are at same level");
    else
      Console.WriteLine("Leaves are not at same level");
  }
}

Javascript

class Node {
  constructor(item) {
    this.data = item;
    this.left = null;
    this.right = null;
  }
}

function maxDist(curr)
{
  if (curr === null)
  {

    // if node curr is null then return 0
    return 0;
  }

  // call for maximum height of left subtree
  const leftDist = maxDist(curr.left);

  // call for maximum height of right subtree
  const rightDist = maxDist(curr.right);

  // we are taking max(leftDist, rightDist) because we
  // need to find the maximum height
  // adding 1 to the max(leftDist, rightDist) of them
  // as current node also needs to be counted
  return 1 + Math.max(leftDist, rightDist);
}

function minDist(curr)
{
  if (curr === null)
  {

    // if the node curr is null than we can assume that it
    // is at distance infinity(Number.MAX_SAFE_INTEGER)
    // as we have to find the maximum height
    return Number.MAX_SAFE_INTEGER;
  }

  if (curr.left === null && curr.right === null)
  {

    // if the node curr is leaf node then simply return 1
    return 1;
  }

  // call for minimum height of left subtree
  const leftDist = minDist(curr.left);

  // call for minimum height of right subtree
  const rightDist = minDist(curr.right);

  // we are taking min(leftDist, rightDist) because we
  // need to find the minimum height
  // add 1 to the min(leftDist, rightDist) of them as
  // current node also needs to be counted
  return 1 + Math.min(leftDist, rightDist);
}

const root = 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);

// calling maxDist() function to get maximum height
const maxDistResult = maxDist(root);

// calling minDist() function to get minimum height
const minDistResult = minDist(root);

// comparing both the distances
if (maxDistResult === minDistResult)
{
  console.log('Leaves are at same level');
}
else
{
  console.log('Leaves are not at same level');
}

// THIS CODE IS CONTRIBUTED CHANDAN AGARWAL

Output

Leaves are at same level

Time Complexity : O(n) 

Auxiliary Space : O(n)