Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check whether a given binary tree is perfect or not

  • Difficulty Level : Easy
  • Last Updated : 08 Mar, 2022

Given a Binary Tree, write a function to check whether the given Binary Tree is a perfect Binary Tree or not.
A Binary tree is Perfect Binary Tree in which all internal nodes have two children and all leaves are at same level.

Examples: 
The following tree is a perfect binary tree 

               10
           /       \  
         20         30  
        /  \        /  \
      40    50    60   70


               18
           /       \  
         15         30

The following tree is not a perfect binary tree 

      1
    /    \
   2       3
    \     /  \   
     4   5    6

A Perfect Binary Tree of height h (where height is number of nodes on path from root to leaf) has 2h – 1 nodes.
Below is an idea to check whether a given Binary Tree is perfect or not.  

  1. Find depth of any node (in below tree we find depth of leftmost node). Let this depth be d.
  2. Now recursively traverse the tree and check for following two conditions. 
    • Every internal node should have both children non-empty
    • All leaves are at depth ‘d’

C++




// C++ program to check whether a given
// Binary Tree is Perfect or not
#include<bits/stdc++.h>
 
/*  Tree node structure */
struct Node
{
    int key;
    struct Node *left, *right;
};
 
// Returns depth of leftmost leaf.
int findADepth(Node *node)
{
   int d = 0;
   while (node != NULL)
   {
      d++;
      node = node->left;
   }
   return d;
}
 
/* This function tests if a binary tree is perfect
   or not. It basically checks for two things :
   1) All leaves are at same level
   2) All internal nodes have two children */
bool isPerfectRec(struct Node* root, int d, int level = 0)
{
    // An empty tree is perfect
    if (root == NULL)
        return true;
 
    // If leaf node, then its depth must be same as
    // depth of all other leaves.
    if (root->left == NULL && root->right == NULL)
        return (d == level+1);
 
    // If internal node and one child is empty
    if (root->left == NULL || root->right == NULL)
        return false;
 
    // Left and right subtrees must be perfect.
    return isPerfectRec(root->left, d, level+1) &&
           isPerfectRec(root->right, d, level+1);
}
 
// Wrapper over isPerfectRec()
bool isPerfect(Node *root)
{
   int d = findADepth(root);
   return isPerfectRec(root, d);
}
 
/* Helper function that allocates a new node with the
   given key and NULL left and right pointer. */
struct Node *newNode(int k)
{
    struct Node *node = new Node;
    node->key = k;
    node->right = node->left = NULL;
    return node;
}
 
// Driver Program
int main()
{
    struct Node* root = NULL;
    root = newNode(10);
    root->left = newNode(20);
    root->right = newNode(30);
 
    root->left->left = newNode(40);
    root->left->right = newNode(50);
    root->right->left = newNode(60);
    root->right->right = newNode(70);
 
    if (isPerfect(root))
        printf("Yes\n");
    else
        printf("No\n");
 
    return(0);
}
Java



// Java program to check whether a given
// Binary Tree is Perfect or not
class GfG {
 
/* Tree node structure */
static class Node
{
    int key;
    Node left, right;
}
 
// Returns depth of leftmost leaf.
static int findADepth(Node node)
{
int d = 0;
while (node != null)
{
    d++;
    node = node.left;
}
return d;
}
 
/* This function tests if a binary tree is perfect
or not. It basically checks for two things :
1) All leaves are at same level
2) All internal nodes have two children */
static boolean isPerfectRec(Node root, int d, int level)
{
    // An empty tree is perfect
    if (root == null)
        return true;
 
    // If leaf node, then its depth must be same as
    // depth of all other leaves.
    if (root.left == null && root.right == null)
        return (d == level+1);
 
    // If internal node and one child is empty
    if (root.left == null || root.right == null)
        return false;
 
    // Left and right subtrees must be perfect.
    return isPerfectRec(root.left, d, level+1) && isPerfectRec(root.right, d, level+1);
}
 
// Wrapper over isPerfectRec()
static boolean isPerfect(Node root)
{
int d = findADepth(root);
return isPerfectRec(root, d, 0);
}
 
/* Helper function that allocates a new node with the
given key and NULL left and right pointer. */
static Node newNode(int k)
{
    Node node = new Node();
    node.key = k;
    node.right = null;
    node.left = null;
    return node;
}
 
// Driver Program
public static void main(String args[])
{
    Node root = null;
    root = newNode(10);
    root.left = newNode(20);
    root.right = newNode(30);
 
    root.left.left = newNode(40);
    root.left.right = newNode(50);
    root.right.left = newNode(60);
    root.right.right = newNode(70);
 
    if (isPerfect(root) == true)
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
Python3



# Python3 program to check whether a
# given Binary Tree is Perfect or not
 
# Helper class that allocates a new
# node with the given key and None
# left and right pointer.
class newNode:
    def __init__(self, k):
        self.key = k
        self.right = self.left = None
 
# Returns depth of leftmost leaf.
def findADepth(node):
    d = 0
    while (node != None):
        d += 1
        node = node.left
    return d
 
# This function tests if a binary tree
# is perfect or not. It basically checks
# for two things :
# 1) All leaves are at same level
# 2) All internal nodes have two children
def isPerfectRec(root, d, level = 0):
     
    # An empty tree is perfect
    if (root == None):
        return True
 
    # If leaf node, then its depth must
    # be same as depth of all other leaves.
    if (root.left == None and root.right == None):
        return (d == level + 1)
 
    # If internal node and one child is empty
    if (root.left == None or root.right == None):
        return False
 
    # Left and right subtrees must be perfect.
    return (isPerfectRec(root.left, d, level + 1) and
            isPerfectRec(root.right, d, level + 1))
 
# Wrapper over isPerfectRec()
def isPerfect(root):
    d = findADepth(root)
    return isPerfectRec(root, d)
 
# Driver Code
if __name__ == '__main__':
    root = None
    root = newNode(10)
    root.left = newNode(20)
    root.right = newNode(30)
 
    root.left.left = newNode(40)
    root.left.right = newNode(50)
    root.right.left = newNode(60)
    root.right.right = newNode(70)
 
    if (isPerfect(root)):
        print("Yes")
    else:
        print("No")
         
# This code is contributed by pranchalK
C#



// C# program to check whether a given
// Binary Tree is Perfect or not
using System;
 
class GfG
{
 
/* Tree node structure */
class Node
{
    public int key;
    public Node left, right;
}
 
// Returns depth of leftmost leaf.
static int findADepth(Node node)
{
    int d = 0;
    while (node != null)
    {
        d++;
        node = node.left;
    }
    return d;
}
 
/* This function tests if a binary tree is perfect
or not. It basically checks for two things :
1) All leaves are at same level
2) All internal nodes have two children */
static bool isPerfectRec(Node root,
                    int d, int level)
{
    // An empty tree is perfect
    if (root == null)
        return true;
 
    // If leaf node, then its depth must be same as
    // depth of all other leaves.
    if (root.left == null && root.right == null)
        return (d == level+1);
 
    // If internal node and one child is empty
    if (root.left == null || root.right == null)
        return false;
 
    // Left and right subtrees must be perfect.
    return isPerfectRec(root.left, d, level+1) &&
            isPerfectRec(root.right, d, level+1);
}
 
// Wrapper over isPerfectRec()
static bool isPerfect(Node root)
{
    int d = findADepth(root);
    return isPerfectRec(root, d, 0);
}
 
/* Helper function that allocates a new node with the
given key and NULL left and right pointer. */
static Node newNode(int k)
{
    Node node = new Node();
    node.key = k;
    node.right = null;
    node.left = null;
    return node;
}
 
// Driver code
public static void Main()
{
    Node root = null;
    root = newNode(10);
    root.left = newNode(20);
    root.right = newNode(30);
 
    root.left.left = newNode(40);
    root.left.right = newNode(50);
    root.right.left = newNode(60);
    root.right.right = newNode(70);
 
    if (isPerfect(root) == true)
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
 
/* This code is contributed by Rajput-Ji*/
Javascript



<script>
  
// Javascript program to check whether a given
// Binary Tree is Perfect or not
 
/* Tree node structure */
class Node
{
    constructor()
    {
        this.key = 0;
        this.left = null;
        this.right = null;
    }
}
 
// Returns depth of leftmost leaf.
function findADepth(node)
{
    var d = 0;
     
    while (node != null)
    {
        d++;
        node = node.left;
    }
    return d;
}
 
/* This function tests if a binary tree is perfect
or not. It basically checks for two things :
1) All leaves are at same level
2) All internal nodes have two children */
function isPerfectRec(root, d, level)
{
     
    // An empty tree is perfect
    if (root == null)
        return true;
 
    // If leaf node, then its depth must be same as
    // depth of all other leaves.
    if (root.left == null && root.right == null)
        return (d == level + 1);
 
    // If internal node and one child is empty
    if (root.left == null || root.right == null)
        return false;
 
    // Left and right subtrees must be perfect.
    return isPerfectRec(root.left, d, level + 1) &&
           isPerfectRec(root.right, d, level + 1);
}
 
// Wrapper over isPerfectRec()
function isPerfect(root)
{
    var d = findADepth(root);
    return isPerfectRec(root, d, 0);
}
 
/* Helper function that allocates a new node with the
given key and NULL left and right pointer. */
function newNode(k)
{
    var node = new Node();
    node.key = k;
    node.right = null;
    node.left = null;
    return node;
}
 
// Driver code
var root = null;
root = newNode(10);
root.left = newNode(20);
root.right = newNode(30);
root.left.left = newNode(40);
root.left.right = newNode(50);
root.right.left = newNode(60);
root.right.right = newNode(70);
if (isPerfect(root) == true)
    document.write("Yes");
else
    document.write("No");
 
// This code is contributed by noob2000
 
</script>
Output: 
Yes
Time complexity: O(n) 
Method 2: Using the length of the binary tree
Since a full binary tree has 2^h – 1 nodes, we can count the number of nodes in the binary tree and determine whether it is a power of 2 or not.
To efficiently determine whether it is a power of 2 or not, we can use bitwise operation x & (x+1) == 0
Python3



# Python3 program to check whether a
# given Binary Tree is Perfect or not
 
# Helper class that allocates a new
# node with the given key and None
# left and right pointer.
class newNode:
    def __init__(self, k):
        self.key = k
        self.right = self.left = None
 
#This functions gets the size of binary tree
#Basically, the number of nodes this binary tree has
def getLength(root):
  if root == None:
    return 0
  return 1 + getLength(root.left) + getLength(root.right)
 
#Returns True if length of binary tree is a power of 2 else False
def isPerfect(root):
  length = getLength(root)
  return length & (length+1) == 0
 
# Driver Code
if __name__ == '__main__':
    root = None
    root = newNode(10)
    root.left = newNode(20)
    root.right = newNode(30)
 
    root.left.left = newNode(40)
    root.left.right = newNode(50)
    root.right.left = newNode(60)
    root.right.right = newNode(70)
 
    if (isPerfect(root)):
        print("Yes")
    else:
        print("No")
         
# This code is contributed by beardedowl
Javascript



<script>
 
// JavaScript program to check whether a
// given Binary Tree is Perfect or not
 
// Helper class that allocates a new
// node with the given key and None
// left and right pointer.
class newNode{
    constructor(k){
        this.key = k
        this.right = this.left = null
    }
}
 
// This functions gets the size of binary tree
// Basically, the number of nodes this binary tree has
function getLength(root){
    if(root == null)
        return 0
    return 1 + getLength(root.left) + getLength(root.right)
}
 
// Returns True if length of binary tree is a power of 2 else False
function isPerfect(root){
    let length = getLength(root)
    return length & (length+1) == 0
}
 
// Driver Code
let root = null
root = new newNode(10)
root.left = new newNode(20)
root.right = new newNode(30)
 
root.left.left = new newNode(40)
root.left.right = new newNode(50)
root.right.left = new newNode(60)
root.right.right = new newNode(70)
 
if (isPerfect(root))
        document.write("Yes")
else
        document.write("No")
         
// This code is contributed by shinjanpatra
 
 
</script>
This article is contributed by Nikhil Papisetty. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes
arrow_drop_up
Next

Check whether a binary tree is a full binary tree or not
Recommended Articles
Page :
Check whether a given binary tree is skewed binary tree or not?
18, Nov 18
Check whether a binary tree is a full binary tree or not
08, Feb 15
Check whether a binary tree is a full binary tree or not | Iterative Approach
19, Dec 17
Check whether a binary tree is a complete tree or not | Set 2 (Recursive Solution)
14, Feb 15
Check whether a given Binary Tree is Complete or not | Set 1 (Iterative Solution)
06, Sep 12
Construct XOR tree by Given leaf nodes of Perfect Binary Tree
13, Jan 20
Iterative approach to check if a Binary Tree is Perfect
26, Mar 19
Check if any level of a perfect Binary Tree forms a Palindrome
27, Jan 22
Check if a Binary Tree is an Even-Odd Tree or not
06, Oct 20
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
19, Jan 18
Find sum of all nodes of the given perfect binary tree
21, Mar 18
Find the largest Perfect Subtree in a given Binary Tree
01, May 19
Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree
15, May 19
Check if a binary tree is subtree of another binary tree | Set 1
15, Aug 11
Check if a binary tree is subtree of another binary tree | Set 2
26, Jul 14
Check if a binary tree is subtree of another binary tree using preorder traversal : Iterative
08, Apr 20
Check if a Binary tree is Subtree of another Binary tree | Set 3
24, Feb 22
Check whether nodes of Binary Tree form Arithmetic, Geometric or Harmonic Progression
25, Mar 20
Check whether every node of binary tree has a value K on itself or its any immediate neighbours
15, Jul 20
Reverse alternate levels of a perfect binary tree
29, Jun 14
Perfect Binary Tree Specific Level Order Traversal
12, Nov 14
Perfect Binary Tree Specific Level Order Traversal | Set 2
24, Apr 16
Print middle level of perfect binary tree without finding height
17, Jul 17
Reverse alternate levels of a perfect binary tree using Stack
26, Mar 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!