# Check if all leaves are at same level

• Difficulty Level : Easy
• Last Updated : 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
```

Method 1 (Recursive)

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

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++ program to check if all leaves``// are at same level``#include ``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 ``#include ` `// 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;``}`

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

 ``

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

 `// C++ program to check if all leaf nodes are at``// same level of binary tree``#include ``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 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;``}`

## 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 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 q = ``new` `Queue();``            ``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

 ``

Output:

`All leaf nodes are at same level`

Time Complexity : O(n)
This code is contributed by Mandeep Singh