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

10 May, 2022
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++
C
Java
Python
C#
Javascript
// C++ program to check if a given// binary tree is complete or not#include <bits/stdc++.h>using namespace std;  /* A binary tree node has data,pointer to left child and apointer to right child */struct node{    int data;    struct node* left;    struct node* right;}; /* Given a binary tree, returntrue if the tree is completeelse 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);    queue<node *> q;    q.push(root);    // 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(!q.empty())    {        node *temp =q.front();        q.pop();         /* Check if left child is present*/        if(temp->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;         q.push(temp->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->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;         q.push(temp->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;}   /* Helper function that allocates a new node with thegiven 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 code*/int main(){    /* Let us construct the following Binary Tree which        is not a complete Binary Tree              1            /  \            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->left = newNode(6);     if ( isCompleteBT(root) == true )        cout << "Complete Binary Tree";    else        cout << "NOT Complete Binary Tree";     return 0;} // This code is contributed by izuna_894
// 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 traversal */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;}
//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
# Check whether a binary tree is complete or not # A binary tree nodeclass 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 falsedef 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 child 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 complete 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)
// C# program to check if a given// binary tree is complete or notusing 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 */
<script>  // JavaScript program to check if a given// binary tree is complete or not /* A binary tree node has data,pointer to left child and a pointer to right child */class Node{    // Constructor    constructor(d)    {        this.data = d;        this.left = null;        this.right = null;    }} /* Given a binary tree, returntrue if the tree is completeelse false */function isCompleteBT(root){    // Base Case: An empty tree    // is complete Binary Tree    if(root == null)        return true;         // Create an empty queue    var queue = [];         // Create a flag variable which will be set true    // when a non full node is seen    var flag = false;         // Do level order traversal using queue.    queue.push(root);    while(queue.length != 0)    {        var temp_node = queue.shift();                 /* 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;                         // push Left Child            queue.push(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;                         // push Right Child            queue.push(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*//* Let us construct the following Binary Tree whichis not a complete Binary Tree        1    / \    2     3    / \     \4 5     6*/var 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)    document.write("Complete Binary Tree");else    document.write("NOT Complete Binary Tree");  </script>
Complete Binary Tree
Time Complexity: O(n) where n is the number of nodes in given Binary TreeAuxiliary Space: O(n) for queue. 
Method 2 :  A more simple approach 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.
C++
Java
C#
// C++ program to check if a given// binary tree is complete or not#include <bits/stdc++.h>using namespace std;    /* A binary tree node has data,pointer to left child and apointer to right child */struct node{    int data;    struct node* left;    struct node* right;};  /* Given a binary tree, returntrue if the tree is completeelse false */bool isCompleteBT(node* root){    // Base Case: An empty tree    // is complete Binary Tree    if (root == NULL)        return true;      // Create an empty queue    queue<node *> q;    q.push(root);    // 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(!q.empty())    {        node *temp =q.front();        q.pop();          if(temp == NULL){        // If we have seen a NULL node,        // we set the flag to true            flag = true ;        }else{            // If that NULL node            // is not the last node            // then return false            if(flag == true){                return false ;            }            // Push both nodes            // even if there are null            q.push(temp->left) ;                       q.push(temp->right) ;        }       }      // If we reach here, then the    // tree is complete Binary Tree    return true;}      /* Helper function that allocates a new node with thegiven 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 code*/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->left = newNode(6);      if ( isCompleteBT(root) == true )        cout << "Complete Binary Tree";    else        cout << "NOT Complete Binary Tree";      return 0;}
// Java program to check if a given// binary tree is complete or notimport java.util.*; class GFG{  /* A binary tree node has data,pointer to left child and apointer to right child */static class node{    int data;    node left;    node right;};  /* Given a binary tree, returntrue if the tree is completeelse 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 > q = new LinkedList<>();    q.add(root);       // 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.    //enQueue(queue, &rear, root);    while(!q.isEmpty())    {        node temp =q.peek();        q.remove();          if(temp == null)        {                   // If we have seen a null node,        // we set the flag to true            flag = true ;        }      else      {            // If that null node            // is not the last node            // then return false            if(flag == true)            {                return false ;            }                     // Push both nodes            // even if there are null            q.add(temp.left) ;                       q.add(temp.right) ;        }       }      // If we reach here, then the    // tree is complete Binary Tree    return true;}  /* Helper function that allocates a new node with thegiven data and null left and right pointers. */static node newNode(int data){    node node = new node();    node.data = data;    node.left = null;    node.right = null;    return(node);}  /* Driver code*/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 = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.left.right = newNode(5);    root.right.left = newNode(6);      if ( isCompleteBT(root) == true )        System.out.print("Complete Binary Tree");    else        System.out.print("NOT Complete Binary Tree");  }}  // This code is contributed by Rajput-Ji
// C# program to check if a given// binary tree is complete or notusing System;using System.Collections.Generic; class GFG{ /* A binary tree node has data,pointer to left child and apointer to right child */ public class node{    public int data;    public node left;    public node right;} /* Given a binary tree, returntrue if the tree is completeelse 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 > q = new Queue<node>();    q.Enqueue(root);     // 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(q.Count!=0)    {        node temp =q.Peek();        q.Dequeue();         if(temp == null)        {                 // If we have seen a null node,        // we set the flag to true            flag = true ;        }    else    {            // If that null node            // is not the last node            // then return false            if(flag == true)            {                return false ;            }                     // Push both nodes            // even if there are null            q.Enqueue(temp.left) ;                   q.Enqueue(temp.right) ;        }    }     // If we reach here, then the    // tree is complete Binary Tree    return true;} /* Helper function that allocates a new node with thegiven data and null left and right pointers. */public static  node newNode(int data){    node node = new node();    node.data = data;    node.left = null;    node.right = null;    return(node);}  // Driver Codepublic 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 = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.left.right = newNode(5);    root.right.left = newNode(6);     if ( isCompleteBT(root) == true )        Console.Write("Complete Binary Tree");    else        Console.Write("NOT Complete Binary Tree"); }} // This code is contributed by jana_sayantan.
Complete Binary Tree
Time Complexity: O(n) where n is the number of nodes in given Binary Tree
Auxiliary Space: O(n) for queue. 
YouTubeGeeksforGeeks507K subscribersCheck whether a given Binary Tree is Complete or not | Set 1 (Iterative Solution) | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You'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.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:51•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=IPak9nF_64k" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem. 
princiraj1992
rathbhupendra
Akanksha_Rai
IZUNA_894
anikakapoor
rutvik_56
surindertarika1234
surinderdawra388
prasanna1995
kk9826225
GauravRajput1
sagartomar9927
jana_sayantan
Queue
Tree
Queue
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Queue | Set 1 (Introduction and Array Implementation)
Priority Queue | Set 1 (Introduction)
LRU Cache Implementation
Queue - Linked List Implementation
Circular Queue | Set 1 (Introduction and Array Implementation)
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
AVL Tree | Set 1 (Insertion)
Binary Tree | Set 3 (Types of Binary Tree)
Inorder Tree Traversal without Recursion