Linked complete binary tree & its creation - GeeksforGeeks

10 Nov, 2020
A complete binary tree is a binary tree where each level ‘l’ except the last has 2^l nodes and the nodes at the last level are all left-aligned. Complete binary trees are mainly used in heap-based data structures. The nodes in the complete binary tree are inserted from left to right in one level at a time. If a level is full, the node is inserted in a new level.Below are some complete binary trees.  
       1
      / \
     2   3

        1
       / \
      2   3
     / \  / 
    4  5 6


Below binary trees are not complete:   
     1
    / \
   2   3
  /    /
  4   5

       1
      / \
     2   3
    / \  /
   4  5 6
  /
 7

Complete binary trees are generally represented using arrays. The array representation is better because it doesn’t contain any empty slots. Given parent index i, its left child is given by 2 * i + 1, and its right child is given by 2 * i + 2. So no extra space is wasted and space to store left and right pointers is saved. However, it may be an interesting programming question to create a Complete Binary Tree using linked representation. Here Linked means a non-array representation where the left and right pointers(or references) are used to refer left and right children respectively. How to write an insert function that always adds a new node in the last level and at the leftmost available position? To create a linked complete binary tree, we need to keep track of the nodes in a level order fashion such that the next node to be inserted lies in the leftmost position. A queue data structure can be used to keep track of the inserted nodes. The following are steps to insert a new node in Complete Binary Tree. 1. If the tree is empty, initialize the root with a new node.2. Else, get the front node of the queue. .......If the left child of this front node doesn’t exist, set the left child as the new node. .......else if the right child of this front node doesn’t exist, set the right child as the new node.3. If the front node has both the left child and right child, Dequeue() it.4. Enqueue() the new node.Below is the implementation:  
C
C++
Python3
// Program for linked implementation of complete binary tree#include <stdio.h>#include <stdlib.h> // For Queue Size#define SIZE 50 // A tree nodestruct node{    int data;    struct node *right,*left;}; // A queue nodestruct Queue{    int front, rear;    int size;    struct node* *array;}; // A utility function to create a new tree nodestruct node* newNode(int data){    struct node* temp = (struct node*) malloc(sizeof( struct node ));    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // A utility function to create a new Queuestruct Queue* createQueue(int size){    struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));     queue->front = queue->rear = -1;    queue->size = size;     queue->array = (struct node**) malloc                   (queue->size * sizeof( struct node* ));     int i;    for (i = 0; i < size; ++i)        queue->array[i] = NULL;     return queue;} // Standard Queue Functionsint isEmpty(struct Queue* queue){    return queue->front == -1;} int isFull(struct Queue* queue){  return queue->rear == queue->size - 1; } int hasOnlyOneItem(struct Queue* queue){  return queue->front == queue->rear;  } void Enqueue(struct node *root, struct Queue* queue){    if (isFull(queue))        return;     queue->array[++queue->rear] = root;     if (isEmpty(queue))        ++queue->front;} struct node* Dequeue(struct Queue* queue){    if (isEmpty(queue))        return NULL;     struct node* temp = queue->array[queue->front];     if (hasOnlyOneItem(queue))        queue->front = queue->rear = -1;    else        ++queue->front;     return temp;} struct node* getFront(struct Queue* queue){  return queue->array[queue->front]; } // A utility function to check if a tree node// has both left and right childrenint hasBothChild(struct node* temp){    return temp && temp->left && temp->right;} // Function to insert a new node in complete binary treevoid insert(struct node **root, int data, struct Queue* queue){    // Create a new node for given data    struct node *temp = newNode(data);     // If the tree is empty, initialize the root with new node.    if (!*root)        *root = temp;     else    {        // get the front node of the queue.        struct node* front = getFront(queue);         // If the left child of this front node doesn’t exist, set the        // left child as the new node        if (!front->left)            front->left = temp;         // If the right child of this front node doesn’t exist, set the        // right child as the new node        else if (!front->right)            front->right = temp;         // If the front node has both the left child and right child,        // Dequeue() it.        if (hasBothChild(front))            Dequeue(queue);    }     // Enqueue() the new node for later insertions    Enqueue(temp, queue);} // Standard level order traversal to test above functionvoid levelOrder(struct node* root){    struct Queue* queue = createQueue(SIZE);     Enqueue(root, queue);     while (!isEmpty(queue))    {        struct node* temp = Dequeue(queue);         printf("%d ", temp->data);         if (temp->left)            Enqueue(temp->left, queue);         if (temp->right)            Enqueue(temp->right, queue);    }} // Driver program to test above functionsint main(){    struct node* root = NULL;    struct Queue* queue = createQueue(SIZE);    int i;     for(i = 1; i <= 12; ++i)        insert(&root, i, queue);     levelOrder(root);     return 0;}
// Program for linked implementation of complete binary tree#include <bits/stdc++.h>using namespace std; // For Queue Size#define SIZE 50 // A tree nodeclass node{    public:    int data;    node *right,*left;}; // A queue nodeclass Queue{    public:    int front, rear;    int size;    node**array;}; // A utility function to create a new tree nodenode* newNode(int data){    node* temp = new node();    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // A utility function to create a new QueueQueue* createQueue(int size){    Queue* queue = new Queue();     queue->front = queue->rear = -1;    queue->size = size;     queue->array = new node*[queue->size * sizeof( node* )];     int i;    for (i = 0; i < size; ++i)        queue->array[i] = NULL;     return queue;} // Standard Queue Functionsint isEmpty(Queue* queue){    return queue->front == -1;} int isFull(Queue* queue){ return queue->rear == queue->size - 1; } int hasOnlyOneItem(Queue* queue){ return queue->front == queue->rear; } void Enqueue(node *root, Queue* queue){    if (isFull(queue))        return;     queue->array[++queue->rear] = root;     if (isEmpty(queue))        ++queue->front;} node* Dequeue(Queue* queue){    if (isEmpty(queue))        return NULL;     node* temp = queue->array[queue->front];     if (hasOnlyOneItem(queue))        queue->front = queue->rear = -1;    else        ++queue->front;     return temp;} node* getFront(Queue* queue){ return queue->array[queue->front]; } // A utility function to check if a tree node// has both left and right childrenint hasBothChild(node* temp){    return temp && temp->left && temp->right;} // Function to insert a new node in complete binary treevoid insert(node **root, int data, Queue* queue){    // Create a new node for given data    node *temp = newNode(data);     // If the tree is empty, initialize the root with new node.    if (!*root)        *root = temp;     else    {        // get the front node of the queue.        node* front = getFront(queue);         // If the left child of this front node doesn’t exist, set the        // left child as the new node        if (!front->left)            front->left = temp;         // If the right child of this front node doesn’t exist, set the        // right child as the new node        else if (!front->right)            front->right = temp;         // If the front node has both the left child and right child,        // Dequeue() it.        if (hasBothChild(front))            Dequeue(queue);    }     // Enqueue() the new node for later insertions    Enqueue(temp, queue);} // Standard level order traversal to test above functionvoid levelOrder(node* root){    Queue* queue = createQueue(SIZE);     Enqueue(root, queue);     while (!isEmpty(queue))    {        node* temp = Dequeue(queue);         cout<<temp->data<<" ";         if (temp->left)            Enqueue(temp->left, queue);         if (temp->right)            Enqueue(temp->right, queue);    }} // Driver program to test above functionsint main(){    node* root = NULL;    Queue* queue = createQueue(SIZE);    int i;     for(i = 1; i <= 12; ++i)        insert(&root, i, queue);     levelOrder(root);     return 0;} //This code is contributed by rathbhupendra
# Program for linked implementation# of complete binary tree # For Queue SizeSIZE = 50 # A tree nodeclass node:         def __init__(self, data):               self.data = data        self.right = None        self.left = None # A queue nodeclass Queue:         def __init__(self):               self.front = None        self.rear = None        self.size = 0        self.array = [] # A utility function to# create a new tree nodedef newNode(data):         temp = node(data)    return temp # A utility function to# create a new Queuedef createQueue(size):         global queue       queue = Queue();    queue.front = queue.rear = -1;    queue.size = size;    queue.array = [None for i in range(size)]    return queue;     # Standard Queue Functionsdef isEmpty(queue):     return queue.front == -1 def isFull(queue):         return queue.rear == queue.size - 1; def hasOnlyOneItem(queue):         return queue.front == queue.rear; def Enqueue(root):     if (isFull(queue)):        return;         queue.rear+=1    queue.array[queue.rear] = root;     if (isEmpty(queue)):        queue.front+=1; def Dequeue():     if (isEmpty(queue)):        return None;     temp = queue.array[queue.front];     if(hasOnlyOneItem(queue)):        queue.front = queue.rear = -1;    else:        queue.front+=1     return temp; def getFront(queue):         return queue.array[queue.front]; # A utility function to check# if a tree node has both left# and right childrendef hasBothChild(temp):     return (temp and temp.left and            temp.right);     # Function to insert a new# node in complete binary treedef insert(root, data, queue):     # Create a new node for    # given data    temp = newNode(data);     # If the tree is empty,    # initialize the root    # with new node.    if not root:        root = temp;    else:             # get the front node of        # the queue.        front = getFront(queue);         # If the left child of this        # front node doesn’t exist,        # set the left child as the        # new node        if (not front.left):            front.left = temp;         # If the right child of this        # front node doesn’t exist, set        # the right child as the new node        elif (not front.right):            front.right = temp;         # If the front node has both the        # left child and right child,        # Dequeue() it.        if (hasBothChild(front)):            Dequeue();     # Enqueue() the new node for    # later insertions    Enqueue(temp);    return root  # Standard level order# traversal to test above# functiondef levelOrder(root):     queue = createQueue(SIZE);    Enqueue(root);         while (not isEmpty(queue)):           temp = Dequeue();                print(temp.data, end = ' ')        if (temp.left):            Enqueue(temp.left);        if (temp.right):            Enqueue(temp.right); # Driver code if __name__ == "__main__":         root = None    queue = createQueue(SIZE);         for i in range(1, 13):        root=insert(root, i,                    queue);          levelOrder(root); # This code is contributed by Rutvik_56
1 2 3 4 5 6 7 8 9 10 11 12







 
This article is compiled by Aashish Barnwal and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
rathbhupendra
rutvik_56
Complete Binary Tree
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Introduction to Tree Data Structure
DFS traversal of a tree using recursion
Difference between B tree and B+ tree
Construct Complete Binary Tree from its Linked List Representation
2-3 Trees | (Search, Insert and Deletion)
Difference between Min Heap and Max Heap
Iterative Postorder Traversal | Set 2 (Using One Stack)
Find the node with minimum value in a Binary Search Tree
Binary Tree to Binary Search Tree Conversion
Threaded Binary Tree