Aquileo | Check whether a given Binary Tree is Complete or not (Iterative Solution)

Given a Binary Tree, the task is to check whether the given Binary Tree is a Complete Binary Tree or not.
A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.

Examples:

The following trees are examples of Complete Binary Trees:

The following trees are examples of Non-Complete Binary Trees:

Try It Yourself

Table of Content

[Expected Approach - 1] Using Level-Order Traversal - O(n) Time and O(n) Space
[Expected Approach - 2] Checking position of NULL - O(n) Time and O(n) Space

[Expected Approach - 1] Using Level-Order Traversal - O(n) Time and O(n) Space

The idea is to do a level order traversal starting from the root. In the traversal, once a node is found which is Not a Full Node, all the following nodes must be leaf nodes. A node is ‘Full Node’ if both left and right children are not empty (or not NULL).

Also, one more thing needs to be checked to handle the below case: If a node has an empty left child, then the right child must be empty.

Below is the implementation of the above approach:

C++

// C++ implementation to check if a 
// Binary Tree is complete
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

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

// Function to check if the binary tree is complete
bool isCompleteBinaryTree(Node* root) {
    if (root == nullptr)
        return true;

    queue<Node*> q;
    q.push(root);
    bool end = false; 

    while (!q.empty()) {
        Node* current = q.front();
        q.pop();

        // Check left child
        if (current->left) {
            if (end) 
                return false;
            q.push(current->left);
        } 
       else {
         
            // If left child is missing,
         	// mark the end
            end = true;
        }

        // Check right child
        if (current->right) {
            if (end) 
                return false;
          
            q.push(current->right);
        } 
       else {
         
            // If right child is missing,
         	// mark the end
            end = true;
        }
    }

    return true; 
}

int main() {
  
    // Representation of Input tree
    //         1
    //        /  \
    //       2    3
    //      / \   /
    //     4   5  6
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6); 
    
    if (isCompleteBinaryTree(root))
        cout << "True" << endl;
    else
        cout << "False" << endl;

    return 0;
}

Java

// Java implementation to check if a 
// Binary Tree is complete
import java.util.LinkedList;
import java.util.Queue;

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

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

class GfG {
  
    // Function to check if the binary
  	// tree is complete
    static boolean isCompleteBinaryTree(Node root) {
        if (root == null)
            return true;

        Queue<Node> q = new LinkedList<>();
        q.add(root);
        boolean end = false; 

        while (!q.isEmpty()) {
            Node current = q.poll();

            // Check left child
            if (current.left != null) {
                if (end) 
                    return false;
                q.add(current.left);
            } 
            else {
              
                // If left child is missing,
              	// mark the end
                end = true;
            }

            // Check right child
            if (current.right != null) {
                if (end) 
                    return false;
                q.add(current.right);
            } 
            else {
              
                // If right child is missing,
              	// mark the end
                end = true;
            }
        }

        return true; 
    }

    public static void main(String[] args) {
      
        // Representation of Input tree
        //         1
        //        /  \
        //       2    3
        //      / \   /
        //     4   5  6
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6); 
        
        if (isCompleteBinaryTree(root))
            System.out.println("True");
        else
            System.out.println("False");
    }
}

Python

# Python implementation to check if a 
# Binary Tree is complete
from collections import deque

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

# Function to check if the binary 
# tree is complete
def is_complete_binary_tree(root):
    if root is None:
        return True

    q = deque([root])
    end = False 

    while q:
        current = q.popleft()

        # Check left child
        if current.left:
            if end:
                return False
            q.append(current.left)
        else:
          
            # If left child is missing,
            # mark the end
            end = True

        # Check right child
        if current.right:
            if end:
                return False
            q.append(current.right)
        else:
          
            # If right child is missing, 
            # mark the end
            end = True

    return True 

if __name__ == "__main__":
  
    # Representation of Input tree
    #         1
    #        /  \
    #       2    3
    #      / \   /
    #     4   5  6
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6) 
    
    if is_complete_binary_tree(root):
        print("True")
    else:
        print("False")

// C# implementation to check if a 
// Binary Tree is complete
using System;
using System.Collections.Generic;

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

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

// Function to check if the binary
// tree is complete
class GfG {
    static bool isCompleteBinaryTree(Node root) {
        if (root == null)
            return true;

        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);
        bool end = false; 

        while (q.Count > 0) {
            Node current = q.Dequeue();

            // Check left child
            if (current.left != null) {
                if (end)
                    return false;
                q.Enqueue(current.left);
            } 
            else {
              
                // If left child is missing, 
              	// mark the end
                end = true;
            }

            // Check right child
            if (current.right != null) {
                if (end)
                    return false;
                q.Enqueue(current.right);
            } 
            else {
              
                // If right child is missing,
              	// mark the end
                end = true;
            }
        }

        return true; 
    }

    static void Main(string[] args) {
      
        // Representation of Input tree
        //         1
        //        /  \
        //       2    3
        //      / \   /
        //     4   5  6
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6); 
        
        if (isCompleteBinaryTree(root))
            Console.WriteLine("True");
        else
            Console.WriteLine("False");
    }
}

JavaScript

// JavaScript implementation to check if a 
// Binary Tree is complete
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to check if the binary
// tree is complete
function isCompleteBinaryTree(root) {
    if (root === null)
        return true;

    const q = [];
    q.push(root);
    let end = false; 

    while (q.length > 0) {
        const current = q.shift();

        // Check left child
        if (current.left) {
            if (end)
                return false;
            q.push(current.left);
        } 
        else {
        
            // If left child is missing,
            // mark the end
            end = true;
        }

        // Check right child
        if (current.right) {
            if (end)
                return false;
            q.push(current.right);
        } 
        else {
        
            // If right child is missing,
            // mark the end
            end = true;
        }
    }

    return true; 
}

// Representation of Input tree
//         1
//        /  \
//       2    3
//      / \   /
//     4   5  6
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6); 

if (isCompleteBinaryTree(root))
    console.log("True");
else
    console.log("False");

Output

True

[Expected Approach - 2] Checking position of NULL - O(n) Time and O(n) Space

A simple idea would be to check whether the NULL Node encountered is the last node of the Binary Tree. If the null node encountered in the binary tree is the last node then it is a complete binary tree and if there exists a valid node even after encountering a null node then the tree is not a complete binary tree.