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

Given a Binary Tree, write a function to check whether the given Binary Tree is 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. See the following examples.

The following trees are examples of Complete Binary Trees
    1
  /   \
 2     3
  
       1
    /    \
   2       3
  /
 4

       1
    /    \
   2      3
  /  \    /
 4    5  6
The following trees are examples of Non-Complete Binary Trees
    1
      \
       3
  
       1
    /    \
   2       3
    \     /  \   
     4   5    6

       1
    /    \
   2      3
         /  \
        4    5

The method 2 of level order traversal post can be easily modified to check whether a tree is Complete or not. To understand the approach, let us first define the term ‘Full Node’. A node is ‘Full Node’ if both left and right children are not empty (or not NULL).
The approach 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.
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.

    1
  /   \
 2     3
  \
   4

Thanks to Guddu Sharma for suggesting this simple and efficient approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if a given
// binary tree is complete or not 
#include <bits/stdc++.h>
using namespace std;
  
#define MAX_Q_SIZE 500 
  
/* A binary tree node has data,
pointer to left child and a
pointer to right child */
class node 
    public:
    int data; 
    node* left; 
    node* right; 
}; 
  
/* function prototypes for functions 
needed for Queue data structure. A 
queue is needed for level order tarversal */
node** createQueue(int *, int *); 
void enQueue(node **, int *, node *); 
node *deQueue(node **, int *); 
bool isQueueEmpty(int *front, int *rear); 
  
/* Given a binary tree, return 
true if the tree is complete 
else false */
bool isCompleteBT(node* root) 
    // Base Case: An empty tree 
    // is complete Binary Tree 
    if (root == NULL) 
        return true
      
    // Create an empty queue 
    int rear, front; 
    node **queue = createQueue(&front, &rear); 
      
    // Create a flag variable which will be set true 
    // when a non full node is seen 
    bool flag = false
      
    // Do level order traversal using queue. 
    enQueue(queue, &rear, root); 
    while(!isQueueEmpty(&front, &rear)) 
    
        node *temp_node = deQueue(queue, &front); 
      
        /* Check if left child is present*/
        if(temp_node->left) 
        
        // If we have seen a non full node, 
        // and we see a node with non-empty 
        // left child, then the given tree is not 
        // a complete Binary Tree 
        if (flag == true
            return false
      
        enQueue(queue, &rear, temp_node->left); // Enqueue Left Child 
        
        else // If this a non-full node, set the flag as true 
        flag = true
      
        /* Check if right child is present*/
        if(temp_node->right) 
        
        // If we have seen a non full node, 
        // and we see a node with non-empty 
        // right child, then the given tree is not 
        // a complete Binary Tree 
        if(flag == true
            return false
      
        enQueue(queue, &rear, temp_node->right); // Enqueue Right Child 
        
        else // If this a non-full node, set the flag as true 
        flag = true
    
      
    // If we reach here, then the 
    // tree is complete Binary Tree 
    return true
  
  
/*UTILITY FUNCTIONS*/
node** createQueue(int *front, int *rear) 
    node **queue = new node*();
      
    *front = *rear = 0; 
    return queue; 
  
void enQueue(node **queue, int *rear, node *new_node) 
    queue[*rear] = new_node; 
    (*rear)++; 
  
node *deQueue(node **queue, int *front) 
    (*front)++; 
    return queue[*front - 1]; 
  
bool isQueueEmpty(int *front, int *rear) 
    return (*rear == *front); 
  
/* Helper function that allocates a new node with the 
given data and NULL left and right pointers. */
node* newNode(int data) 
    node* Node = new node();
    Node->data = data; 
    Node->left = NULL; 
    Node->right = NULL; 
      
    return(Node); 
  
/* Driver code*/
int main() 
    /* Let us construct the following Binary Tree which 
        is not a complete Binary Tree 
                
            / \ 
            2 3 
            / \ \ 
        4 5 6 
        */
      
    node *root = newNode(1); 
    root->left     = newNode(2); 
    root->right = newNode(3); 
    root->left->left = newNode(4); 
    root->left->right = newNode(5); 
    root->right->right = newNode(6); 
      
    if ( isCompleteBT(root) == true
        cout << "Complete Binary Tree"
    else
        cout << "NOT Complete Binary Tree"
      
    return 0; 
  
// This code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// A program to check if a given binary tree is complete or not
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_Q_SIZE 500
  
/* A binary tree node has data, a pointer to left child
   and a pointer to right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
  
/* function prototypes for functions needed for Queue data
   structure. A queue is needed for level order tarversal */
struct node** createQueue(int *, int *);
void enQueue(struct node **, int *, struct node *);
struct node *deQueue(struct node **, int *);
bool isQueueEmpty(int *front, int *rear);
  
/* Given a binary tree, return true if the tree is complete
   else false */
bool isCompleteBT(struct node* root)
{
  // Base Case: An empty tree is complete Binary Tree
  if (root == NULL)
    return true;
  
  // Create an empty queue
  int rear, front;
  struct node **queue = createQueue(&front, &rear);
  
  // Create a flag variable which will be set true
  // when a non full node is seen
  bool flag = false;
  
  // Do level order traversal using queue.
  enQueue(queue, &rear, root);
  while(!isQueueEmpty(&front, &rear))
  {
    struct node *temp_node = deQueue(queue, &front);
  
    /* Check if left child is present*/
    if(temp_node->left)
    {
       // If we have seen a non full node, and we see a node
       // with non-empty left child, then the given tree is not
       // a complete Binary Tree
       if (flag == true)
         return false;
  
       enQueue(queue, &rear, temp_node->left);  // Enqueue Left Child
    }
    else // If this a non-full node, set the flag as true
       flag = true;
  
    /* Check if right child is present*/
    if(temp_node->right)
    {
       // If we have seen a non full node, and we see a node
       // with non-empty right child, then the given tree is not
       // a complete Binary Tree
       if(flag == true)
         return false;
  
       enQueue(queue, &rear, temp_node->right);  // Enqueue Right Child
    }
    else // If this a non-full node, set the flag as true
       flag = true;
  }
  
  // If we reach here, then the tree is complete Binary Tree
  return true;
}
  
  
/*UTILITY FUNCTIONS*/
struct node** createQueue(int *front, int *rear)
{
  struct node **queue =
   (struct node **)malloc(sizeof(struct node*)*MAX_Q_SIZE);
  
  *front = *rear = 0;
  return queue;
}
  
void enQueue(struct node **queue, int *rear, struct node *new_node)
{
  queue[*rear] = new_node;
  (*rear)++;
}
  
struct node *deQueue(struct node **queue, int *front)
{
  (*front)++;
  return queue[*front - 1];
}
  
bool isQueueEmpty(int *front, int *rear)
{
   return (*rear == *front);
}
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
  struct node* node = (struct node*)
                       malloc(sizeof(struct node));
  node->data = data;
  node->left = NULL;
  node->right = NULL;
  
  return(node);
}
  
/* Driver program to test above functions*/
int main()
{
   /* Let us construct the following Binary Tree which
      is not a complete Binary Tree
            1
          /   \
         2     3
        / \     \
       4   5     6
    */
  
  struct node *root  = newNode(1);
  root->left         = newNode(2);
  root->right        = newNode(3);
  root->left->left   = newNode(4);
  root->left->right  = newNode(5);
  root->right->right = newNode(6);
  
  if ( isCompleteBT(root) == true )
      printf ("Complete Binary Tree");
  else
      printf ("NOT Complete Binary Tree");
  
  return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

//A Java program to check if a given binary tree is complete or not
  
import java.util.LinkedList;
import java.util.Queue;
  
public class CompleteBTree 
{
    /* A binary tree node has data, a pointer to left child
       and a pointer to right child */
    static class Node
    {
        int data;
        Node left;
        Node right;
          
        // Constructor
        Node(int d)
        {
            data = d;
            left = null;
            right = null;
        }
    }
      
    /* Given a binary tree, return true if the tree is complete
       else false */
    static boolean isCompleteBT(Node root)
    {
        // Base Case: An empty tree is complete Binary Tree
        if(root == null)
            return true;
          
        // Create an empty queue
        Queue<Node> queue =new LinkedList<>();
          
        // Create a flag variable which will be set true
        // when a non full node is seen
        boolean flag = false;
          
        // Do level order traversal using queue.
        queue.add(root);
        while(!queue.isEmpty())
        {
            Node temp_node = queue.remove();
              
            /* Check if left child is present*/
            if(temp_node.left != null)
            {
                 // If we have seen a non full node, and we see a node
                 // with non-empty left child, then the given tree is not
                 // a complete Binary Tree
                if(flag == true)
                    return false;
                  
                 // Enqueue Left Child
                queue.add(temp_node.left);
            }
            // If this a non-full node, set the flag as true
            else
                flag = true;
              
            /* Check if right child is present*/
            if(temp_node.right != null)
            {
                // If we have seen a non full node, and we see a node
                // with non-empty right child, then the given tree is not
                // a complete Binary Tree
                if(flag == true)
                    return false;
                  
                // Enqueue Right Child
                queue.add(temp_node.right);
                  
            }
            // If this a non-full node, set the flag as true
            else 
                flag = true;
        }
         // If we reach here, then the tree is complete Binary Tree
        return true;
    }
      
    /* Driver program to test above functions*/
    public static void main(String[] args) 
    {
          
        /* Let us construct the following Binary Tree which
          is not a complete Binary 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.right = new Node(6);
          
        if(isCompleteBT(root) == true)
            System.out.println("Complete Binary Tree");
        else
            System.out.println("NOT Complete Binary Tree");
     }
  
}
//This code is contributed by Sumit Ghosh

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Check whether a binary tree is complete or not
  
# A binary tree node
class Node:
  
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
  
# Given a binary tree, return true if the tree is complete
# else return false
def isCompleteBT(root):
      
    # Base Case: An empty tree is complete Binary tree
    if root is None:
        return True
  
    # Create an empty queue
    queue = []
  
    # Create a flag variable which will be set True 
    # when a non-full node is seen
    flag = False
  
    # Do level order traversal using queue
    queue.append(root)
    while(len(queue) > 0):
        tempNode = queue.pop(0) # Dequeue 
  
        # Check if left child is present
        if (tempNode.left):
              
            # If we have seen a non-full node, and we see
            # a node with non-empty left child, then the
            # given tree is not a complete binary tree
            if flag == True :
                return False
  
            # Enqueue left child
            queue.append(tempNode.left)
  
            # If this a non-full node, set the flag as true
        else:
            flag = True
  
        # Check if right cild is present
        if(tempNode.right):
                  
            # If we have seen a non full node, and we 
            # see a node with non-empty right child, then
            # the given tree is not a compelete BT
            if flag == True:
                return False
  
            # Enqueue right child
            queue.append(tempNode.right)
              
        # If this is non-full node, set the flag as True
        else:
            flag = True
          
    # If we reach here, then the tree is complete BT
    return True
  
  
# Driver program to test above function
  
""" Let us construct the following Binary Tree which
      is not a complete Binary 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.right = Node(6)
  
if (isCompleteBT(root)):
    print "Complete Binary Tree"
else:
    print "NOT Complete Binary Tree"
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to check if a given
// binary tree is complete or not
using System;
using System.Collections.Generic;
  
public class CompleteBTree 
{
    /* A binary tree node has data, 
    pointer to left child and a
     pointer to right child */
    public class Node
    {
        public int data;
        public Node left;
        public Node right;
          
        // Constructor
        public Node(int d)
        {
            data = d;
            left = null;
            right = null;
        }
    }
      
    /* Given a binary tree, return 
    true if the tree is complete
    else false */
    static bool isCompleteBT(Node root)
    {
        // Base Case: An empty tree 
        // is complete Binary Tree
        if(root == null)
            return true;
          
        // Create an empty queue
        Queue<Node> queue = new Queue<Node>();
          
        // Create a flag variable which will be set true
        // when a non full node is seen
        bool flag = false;
          
        // Do level order traversal using queue.
        queue.Enqueue(root);
        while(queue.Count != 0)
        {
            Node temp_node = queue.Dequeue();
              
            /* Check if left child is present*/
            if(temp_node.left != null)
            {
                // If we have seen a non full node,
                // and we see a node with non-empty
                // left child, then the given tree is not
                // a complete Binary Tree
                if(flag == true)
                    return false;
                  
                // Enqueue Left Child
                queue.Enqueue(temp_node.left);
            }
              
            // If this a non-full node, set the flag as true
            else
                flag = true;
              
            /* Check if right child is present*/
            if(temp_node.right != null)
            {
                // If we have seen a non full node,
                // and we see a node with non-empty
                // right child, then the given tree 
                // is not a complete Binary Tree
                if(flag == true)
                    return false;
                  
                // Enqueue Right Child
                queue.Enqueue(temp_node.right);
                  
            }
              
            // If this a non-full node,
            // set the flag as true
            else
                flag = true;
        }
          
        // If we reach here, then the
        // tree is complete Binary Tree
        return true;
    }
      
    /* Driver code*/
    public static void Main() 
    {
          
        /* Let us construct the following Binary Tree which
        is not a complete Binary 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.right = new Node(6);
          
        if(isCompleteBT(root) == true)
            Console.WriteLine("Complete Binary Tree");
        else
            Console.WriteLine("NOT Complete Binary Tree");
    }
}
  
/* This code contributed by PrinciRaj1992 */

chevron_right



Output:

NOT Complete Binary Tree

Time Complexity: O(n) where n is the number of nodes in given Binary Tree

Auxiliary Space: O(n) for queue.

Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


12


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