Check whether a given binary tree is perfect or not

Given a Binary Tree, write a function to check whether the given Binary Tree is a prefect 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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");  


} 


}  



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















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



















                        chevron_right







                        filter_none










Output:


Yes



Time complexity : O(n)







This article is contributed by Nikhil Papisetty. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@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
    

    

        
        

            
            
        

    


Recommended Posts:


					
		

    Article Tags : 
Tree

           	
Practice Tags :  
Amazon
FactSet
Tree

        

         

         
 
                5

                

        



        
        
        
        
        

    

            

            2.2
            

            

             
                 Based on 14 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.