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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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

## 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 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; ` `} `

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

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.