Open In App

Check whether a given binary tree is perfect or not

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a Binary Tree, the task is to check whether the given Binary Tree is a perfect Binary Tree or not.
Note:

  • A Binary tree is a Perfect Binary Tree in which all internal nodes have two children and all leaves are at the same level.
  • A Perfect Binary Tree of height h has 2h – 1 nodes.

Examples: 

Input:

reverse-tree-path-using-queue

Output: True
Explanation: The above tree is the perfect binary tree as all nodes have all nodes have two children and all leaves are at the same level.

Input:

size

Output: False
Explanation: The above tree is not a perfect binary tree since not all nodes have two children.

Table of Content

[Expected Approach - 1] Using Recursive Method - O(n) Time and O(h) Space

The idea is to find the depth of the tree (lets say d) and then check that all the internal nodes have two child nodes and all leaf nodes are at depth d. If not, then return false.

Below is the implementation of the above approach:

C++ 
// C++ program to check if a 
// given binary tree is perfect
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to find depth of tree.
int depth(Node* root) {
    if (root == nullptr)
        return 0;
        
    return 1 + 
    max(depth(root->left), depth(root->right));
}

// Recursive function which checks if 
// tree is perfect or not.
bool isPerfectRecur(Node* root, int d) {
    
    // Empty tree is also perfect 
    if (root==nullptr) return true;
    
    // If node is leaf, check if it 
    // is at depth d.
    if (root->left==nullptr && root->right==nullptr)
        return d == 1;
        
    // If internal node does not have 
    // left or right node, return false.
    if (root->left==nullptr || root->right==nullptr)
        return false;
        
    // Check left and right subtree
    return isPerfectRecur(root->left, d-1) 
    &&
    isPerfectRecur(root->right, d-1);
}

bool isPerfect(Node *root) {
    
    // Find depth of tree 
    int d = depth(root);
    
    return isPerfectRecur(root, d);
}

int main() {
    
    // Binary tree 
    //           10
    //        /     \  
    //      20       30  
    //     /  \     /  \
    //   40    50  60   70
    Node* root = new Node(10);     
    root->left = new Node(20);          
    root->right = new Node(30);         
    root->left->left = new Node(40);   
    root->left->right = new Node(50);  
    root->right->left = new Node(60);   
    root->right->right = new Node(70);  

    if (isPerfect(root)) {
        cout << "True" << endl;
    } else {
        cout << "False" << endl;
    }
    return 0;
}
C 
// C program to check if a 
// given binary tree is perfect
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Function to find depth of tree.
int depth(struct Node* root) {
    if (root == NULL)
        return 0;
    
    int left = depth(root->left);
    int right = depth(root->right);
    return 1 + (left>right?left:right);
}

// Recursive function which checks if 
// tree is perfect or not.
int isPerfectRecur(struct Node* root, int d) {
    
    // Empty tree is also perfect 
    if (root == NULL) return 1;
    
    // If node is leaf, check if it 
    // is at depth d.
    if (root->left == NULL && root->right == NULL)
        return d == 1;
        
    // If internal node does not have 
    // left or right node, return false.
    if (root->left == NULL || root->right == NULL)
        return 0;
        
    // Check left and right subtree
    return isPerfectRecur(root->left, d-1) 
    && isPerfectRecur(root->right, d-1);
}

int isPerfect(struct Node* root) {
    
    // Find depth of tree 
    int d = depth(root);
    
    return isPerfectRecur(root, d);
}

struct Node* createNode(int x) {
    struct Node* newNode = 
    	(struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

int main() {
    
    // Binary tree 
    //           10
    //        /     \  
    //      20       30  
    //     /  \     /  \
    //   40    50  60   70
    struct Node* root = createNode(10);     
    root->left = createNode(20);          
    root->right = createNode(30);         
    root->left->left = createNode(40);   
    root->left->right = createNode(50);  
    root->right->left = createNode(60);   
    root->right->right = createNode(70);  

    if (isPerfect(root)) {
        printf("True\n");
    } else {
        printf("False\n");
    }
    return 0;
}
Java 
// Java program to check if a 
// given binary tree is perfect
class Node {
    int data;
    Node left, right;

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

class GfG {
    
    // Function to find depth of tree.
    static int depth(Node root) {
        if (root == null)
            return 0;
        
        return 1 + Math.max(depth(root.left),
                            depth(root.right));
    }

    // Recursive function which checks if 
    // tree is perfect or not.
    static boolean isPerfectRecur(Node root, int d) {
        
        // Empty tree is also perfect 
        if (root == null) return true;
        
        // If node is leaf, check if it 
        // is at depth d.
        if (root.left == null && root.right == null)
            return d == 1;
        
        // If internal node does not have 
        // left or right node, return false.
        if (root.left == null || root.right == null)
            return false;
        
        // Check left and right subtree
        return isPerfectRecur(root.left, d-1) 
            && isPerfectRecur(root.right, d-1);
    }

    static boolean isPerfect(Node root) {
        
        // Find depth of tree 
        int d = depth(root);
        
        return isPerfectRecur(root, d);
    }

    public static void main(String[] args) {
        
        // Binary tree 
        //           10
        //        /     \  
        //      20       30  
        //     /  \     /  \
        //   40    50  60   70
        Node root = new Node(10);     
        root.left = new Node(20);          
        root.right = new Node(30);         
        root.left.left = new Node(40);   
        root.left.right = new Node(50);  
        root.right.left = new Node(60);   
        root.right.right = new Node(70);  

        if (isPerfect(root)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}
Python 
# Python program to check if a 
# given binary tree is perfect

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

# Function to find depth of tree.
def depth(root):
    if root is None:
        return 0
    return 1 + max(depth(root.left), depth(root.right))

# Recursive function which checks if 
# tree is perfect or not.
def isPerfectRecur(root, d):
    
    # Empty tree is also perfect 
    if root is None:
        return True
    
    # If node is leaf, check if it 
    # is at depth d.
    if root.left is None and root.right is None:
        return d == 1
    
    # If internal node does not have 
    # left or right node, return false.
    if root.left is None or root.right is None:
        return False
    
    # Check left and right subtree
    return isPerfectRecur(root.left, d-1) \
  	and isPerfectRecur(root.right, d-1)

def isPerfect(root):
    
    # Find depth of tree 
    d = depth(root)
    
    return isPerfectRecur(root, d)

if __name__ == "__main__":
    
    # Binary tree 
    #           10
    #        /     \  
    #      20       30  
    #     /  \     /  \
    #   40    50  60   70
    root = Node(10)
    root.left = Node(20)
    root.right = Node(30)
    root.left.left = Node(40)
    root.left.right = Node(50)
    root.right.left = Node(60)
    root.right.right = Node(70)

    if isPerfect(root):
        print("True")
    else:
        print("False")
C# 
// C# program to check if a 
// given binary tree is perfect
using System;

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

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

class GfG {

    // Function to find depth of tree.
    static int depth(Node root) {
        if (root == null)
            return 0;
        
        return 1 + Math.Max(depth(root.left), depth(root.right));
    }

    // Recursive function which checks if 
    // tree is perfect or not.
    static bool isPerfectRecur(Node root, int d) {
        
        // Empty tree is also perfect 
        if (root == null) return true;
        
        // If node is leaf, check if it 
        // is at depth d.
        if (root.left == null && root.right == null)
            return d == 1;
        
        // If internal node does not have 
        // left or right node, return false.
        if (root.left == null || root.right == null)
            return false;
        
        // Check left and right subtree
        return isPerfectRecur(root.left, d-1) 
            && isPerfectRecur(root.right, d-1);
    }

    static bool isPerfect(Node root) {
        
        // Find depth of tree 
        int d = depth(root);
        
        return isPerfectRecur(root, d);
    }

    static void Main (string[] args) {
        
        // Binary tree 
        //           10
        //        /     \  
        //      20       30  
        //     /  \     /  \
        //   40    50  60   70
        Node root = new Node(10);     
        root.left = new Node(20);          
        root.right = new Node(30);         
        root.left.left = new Node(40);   
        root.left.right = new Node(50);  
        root.right.left = new Node(60);   
        root.right.right = new Node(70);  

        if (isPerfect(root)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}
JavaScript 
// JavaScript program to check if a 
// given binary tree is perfect

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

// Function to find depth of tree.
function depth(root) {
    if (root === null)
        return 0;
    
    return 1 + Math.max(depth(root.left),
    		   depth(root.right));
}

// Recursive function which checks if 
// tree is perfect or not.
function isPerfectRecur(root, d) {
    
    // Empty tree is also perfect 
    if (root === null) return true;
    
    // If node is leaf, check if it 
    // is at depth d.
    if (root.left === null && root.right === null)
        return d === 1;
    
    // If internal node does not have 
    // left or right node, return false.
    if (root.left === null || root.right === null)
        return false;
    
    // Check left and right subtree
    return isPerfectRecur(root.left, d-1) 
        && isPerfectRecur(root.right, d-1);
}

function isPerfect(root) {
    
    // Find depth of tree 
    let d = depth(root);
    
    return isPerfectRecur(root, d);
}
    
// Binary tree 
//           10
//        /     \  
//      20       30  
//     /  \     /  \
//   40    50  60   70
let root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(50);
root.right.left = new Node(60);
root.right.right = new Node(70);

if (isPerfect(root)) {
    console.log("True");
} else {
    console.log("False");
}

Output
True

[Expected Approach - 2] Using level order traversal - O(n) Time and O(n) Space

The idea is to perform a level-order traversal of the binary tree using a queue. By traversing the tree level by level, we can check if the tree satisfies the conditions of a perfect binary tree.

Below is the implementation of the above approach:

C++ 
// C++ program to check if a 
// given binary tree is perfect
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

bool isPerfect(Node *root) {
    
    if (root==nullptr) return true;
    
    queue<Node*> q;
    q.push(root);
    
    // to store the expected node 
    // count at a given level.
    int nodeCnt = 1;
    
    while (!q.empty()) {
        int size = q.size();
        
        // If number of expected nodes is 
        // not same, return false.
        if (size != nodeCnt) return false;
        
        while (size--) {
            Node* curr = q.front();
            q.pop();
            
            if (curr->left != nullptr)
                q.push(curr->left);
            if (curr->right != nullptr)
                q.push(curr->right);
        }
        
        // Next level will contain twice
        // number of nodes.
        nodeCnt *= 2;
    }
    
    return true;
}

int main() {
    
    // Binary tree 
    //           10
    //        /     \  
    //      20       30  
    //     /  \     /  \
    //   40    50  60   70
    Node* root = new Node(10);     
    root->left = new Node(20);          
    root->right = new Node(30);         
    root->left->left = new Node(40);   
    root->left->right = new Node(50);  
    root->right->left = new Node(60);   
    root->right->right = new Node(70);  

    if (isPerfect(root)) {
        cout << "True" << endl;
    } else {
        cout << "False" << endl;
    }
    return 0;
}
Java 
// Java program to check if a 
// given binary tree is perfect
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;

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

class GfG {

    static boolean isPerfect(Node root) {
        
        if (root == null) return true;
        
        Queue<Node> q = new LinkedList<>();
        q.add(root);
        
        // to store the expected node 
        // count at a given level.
        int nodeCnt = 1;
        
        while (!q.isEmpty()) {
            int size = q.size();
            
            // If number of expected nodes is 
            // not same, return false.
            if (size != nodeCnt) return false;
            
            while (size-- > 0) {
                Node curr = q.poll();
                
                if (curr.left != null)
                    q.add(curr.left);
                if (curr.right != null)
                    q.add(curr.right);
            }
            
            // Next level will contain twice
            // number of nodes.
            nodeCnt *= 2;
        }
        
        return true;
    }

    public static void main(String[] args) {
        
        // Binary tree 
        //           10
        //        /     \  
        //      20       30  
        //     /  \     /  \
        //   40    50  60   70
        Node root = new Node(10);     
        root.left = new Node(20);          
        root.right = new Node(30);         
        root.left.left = new Node(40);   
        root.left.right = new Node(50);  
        root.right.left = new Node(60);   
        root.right.right = new Node(70);  

        if (isPerfect(root)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}
Python 
# Python program to check if a 
# given binary tree is perfect
from collections import deque

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

def isPerfect(root):
    
    if root is None:
        return True
    
    q = deque([root])
    
    # to store the expected node 
    # count at a given level.
    nodeCnt = 1
    
    while q:
        size = len(q)
        
        # If number of expected nodes is 
        # not same, return False.
        if size != nodeCnt:
            return False
        
        while size > 0:
            curr = q.popleft()
            if curr.left:
                q.append(curr.left)
            if curr.right:
                q.append(curr.right)
            size -= 1
        
        # Next level will contain twice
        # number of nodes.
        nodeCnt *= 2
    
    return True

if __name__ == "__main__":
    
    # Binary tree 
    #           10
    #        /     \  
    #      20       30  
    #     /  \     /  \
    #   40    50  60   70
    root = Node(10)
    root.left = Node(20)
    root.right = Node(30)
    root.left.left = Node(40)
    root.left.right = Node(50)
    root.right.left = Node(60)
    root.right.right = Node(70)

    if isPerfect(root):
        print("True")
    else:
        print("False")
C# 
// C# program to check if a 
// given binary tree is perfect
using System;
using System.Collections.Generic;

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

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

class GfG {
    
    static bool isPerfect(Node root) {
        
        if (root == null) return true;
        
        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);
        
        // to store the expected node 
        // count at a given level.
        int nodeCnt = 1;
        
        while (q.Count > 0) {
            int size = q.Count;
            
            // If number of expected nodes is 
            // not same, return false.
            if (size != nodeCnt) return false;
            
            while (size-- > 0) {
                Node curr = q.Dequeue();
                
                if (curr.left != null)
                    q.Enqueue(curr.left);
                if (curr.right != null)
                    q.Enqueue(curr.right);
            }
            
            // Next level will contain twice
            // number of nodes.
            nodeCnt *= 2;
        }
        
        return true;
    }

    static void Main(string[] args) {
        
        // Binary tree 
        //           10
        //        /     \  
        //      20       30  
        //     /  \     /  \
        //   40    50  60   70
        Node root = new Node(10);
        root.left = new Node(20);
        root.right = new Node(30);
        root.left.left = new Node(40);
        root.left.right = new Node(50);
        root.right.left = new Node(60);
        root.right.right = new Node(70);

        if (isPerfect(root)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}
JavaScript 
// JavaScript program to check if a 
// given binary tree is perfect

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

function isPerfect(root) {
    
    if (root === null) return true;
    
    let q = [];
    q.push(root);
    
    // to store the expected node 
    // count at a given level.
    let nodeCnt = 1;
    
    while (q.length > 0) {
        let size = q.length;
        
        // If number of expected nodes is 
        // not same, return false.
        if (size !== nodeCnt) return false;
        
        while (size-- > 0) {
            let curr = q.shift();
            
            if (curr.left !== null)
                q.push(curr.left);
            if (curr.right !== null)
                q.push(curr.right);
        }
        
        // Next level will contain twice
        // number of nodes.
        nodeCnt *= 2;
    }
    
    return true;
}

// Binary tree 
//           10
//        /     \  
//      20       30  
//     /  \     /  \
//   40    50  60   70
let root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(50);
root.right.left = new Node(60);
root.right.right = new Node(70);

if (isPerfect(root)) {
    console.log("True");
} else {
    console.log("False");
}

Output
True

Check whether a given binary tree is perfect or not
Next Article
Analysis of Algorithms

K

kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

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