Check whether a given binary tree is perfect or not - GeeksforGeeks

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.  
Find depth of any node (in below tree we find depth of leftmost node). Let this depth be d.Now recursively traverse the tree and check for following two conditions. Every internal node should have both children non-emptyAll leaves are at depth ‘d’
Find depth of any node (in below tree we find depth of leftmost node). Let this depth be d.
Now recursively traverse the tree and check for following two conditions. Every internal node should have both children non-emptyAll leaves are at depth ‘d’
Every internal node should have both children non-empty
All leaves are at depth ‘d’
C++
Java
Python3
C#
Javascript
// 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 Programint 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 program to check whether a given// Binary Tree is Perfect or notclass 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 perfector not. It basically checks for two things :1) All leaves are at same level2) 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 thegiven 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 Programpublic 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 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 childrendef 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 Codeif __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# program to check whether a given// Binary Tree is Perfect or notusing 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 perfector not. It basically checks for two things :1) All leaves are at same level2) 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 thegiven 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 codepublic 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*/
<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 perfector not. It basically checks for two things :1) All leaves are at same level2) 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 thegiven 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 codevar 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
Javascript
# 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 hasdef 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 Falsedef isPerfect(root):  length = getLength(root)  return length & (length+1) == 0 # Driver Codeif __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
<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 hasfunction 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 Falsefunction isPerfect(root){    let length = getLength(root)    return length & (length+1) == 0} // Driver Codelet root = nullroot = 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>
YouTubeGeeksforGeeks500K subscribersCheck whether a given binary tree is perfect or not | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou'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.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 3:55•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=08KwCr2UZBQ" 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 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. 
prerna saini
Rajput-Ji
PranchalKatiyar
noob2000
surindertarika1234
beardedowl
shinjanpatra
Amazon
FactSet
Tree
Amazon
FactSet
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Binary Tree | Set 2 (Properties)
Decision Tree
Inorder Tree Traversal without recursion and without stack!
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
Binary Tree (Array implementation)
BFS vs DFS for Binary Tree
Insertion in a Binary Tree in level order