Related Articles

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

• Difficulty Level : Medium
• Last Updated : 06 Jul, 2021

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++ program to check if a given``// binary tree is complete or not``#include ``using` `namespace` `std;`  `/* 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;``};` `/* 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);``    ``queue 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 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``             ``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`

## C

 `// A program to check if a given binary tree is complete or not``#include ``#include ``#include ``#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;``}`

## Java

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

## Python

 `# 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)`

## C#

 `// 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 queue = ``new` `Queue();``        ` `        ``// 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 */`

## Javascript

 ``

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up