  Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email  Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Insertion in a binary tree level order in C

Last Updated on June 29, 2023 by Mayank Dham Binary trees are fundamental data structures used in various algorithms and applications. One common operation performed on binary trees is insertion, where a new node is added to the tree. In this article, we will explore the concept of inserting nodes into a binary tree using the level order traversal technique in the C programming language. We will discuss the algorithm, provide a step-by-step implementation guide, and explain the underlying logic behind each step. So let’s dive into the intricacies of binary tree insertion using level order traversal in C.

## Understanding Binary Trees

Before we delve into the insertion process, let’s briefly review binary trees. A binary tree is a hierarchical data structure consisting of nodes, each having a maximum of two children, namely the left child and the right child. The topmost node in the tree is called the root node, and it serves as the starting point for traversing the tree. The children of a node are often referred to as its left and right subtrees. ## Level Order Traversal

Level order traversal is a popular technique used to traverse a binary tree. It explores the tree level by level, starting from the root node and moving down to the subsequent levels. In this traversal, all the nodes at a particular level are visited before moving on to the next level. It ensures that the nodes are processed in a breadth-first manner.

## Insertion in Binary Trees

To insert a new node into a binary tree using level order traversal, we follow a specific algorithm. Here is a step-by-step guide to performing the insertion:

2. If the root is NULL, create a new node with the given data and set it as the root node.
3. Otherwise, create a queue data structure to hold the nodes during traversal.
4. Enqueue the root node into the queue.
5. Repeat the following steps until the queue becomes empty:
a. Dequeue a node from the front of the queue.
b. Check if the left child of the dequeued node is NULL.

• If so, create a new node with the given data and set it as the left child.
• If not, enqueue the left child into the queue.
c. Check if the right child of the dequeued node is NULL.
• If so, create a new node with the given data and set it as the right child.
• If not, enqueue the right child into the queue.
6. Once the queue is empty, the insertion process is complete.

## C Implementation of Insertion in a binary tree level order

Let’s now implement the insertion algorithm in C, using the step-by-step guide mentioned above:

### C Implementation of Insertion in a binary tree level order

```#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Memory allocation failed!");
exit(1);
}
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}

void insertLevelOrder(struct Node* root, int data) {
// Create a queue for level order traversal
struct Node** queue = (struct Node**)malloc(100 * sizeof(struct Node*));
int front = 0;
int rear = 0;

// If the tree is empty, assign the data to the root
if (root == NULL) {
root = createNode(data);
return;
}

// Enqueue the root node
queue[rear++] = root;

// Iterate through the tree using level order traversal
while (front < rear) {
struct Node* tempNode = queue[front++];

// If the left child is empty, create a new node and assign the data
if (tempNode->left == NULL) {
tempNode->left = createNode(data);
break;
}
// If the left child is not empty, enqueue it
else {
queue[rear++] = tempNode->left;
}

// If the right child is empty, create a new node and assign the data
if (tempNode->right == NULL) {
tempNode->right = createNode(data);
break;
}
// If the right child is not empty, enqueue it
else {
queue[rear++] = tempNode->right;
}
}

free(queue);
}

void levelOrderTraversal(struct Node* root) {
// Create a queue for level order traversal
struct Node** queue = (struct Node**)malloc(100 * sizeof(struct Node*));
int front = 0;
int rear = 0;

// Enqueue the root node
queue[rear++] = root;

// Iterate through the tree using level order traversal
while (front < rear) {
struct Node* tempNode = queue[front++];
printf("%d ", tempNode->data);

// Enqueue the left child if it exists
if (tempNode->left != NULL) {
queue[rear++] = tempNode->left;
}

// Enqueue the right child if it exists
if (tempNode->right != NULL) {
queue[rear++] = tempNode->right;
}
}

free(queue);
}

int main() {
// Create the root node
struct Node* root = createNode(1);

// Perform insertions using level order traversal
insertLevelOrder(root, 2);
insertLevelOrder(root, 3);
insertLevelOrder(root, 4);
insertLevelOrder(root, 5);

// Print the level order traversal
printf("Level Order Traversal: ");
levelOrderTraversal(root);

return 0;
}
```

In the code snippet above, we define a structure `Node` to represent each node in the binary tree. The `createNode()` function creates a new node with the provided data. The `insertLevelOrder()` function performs the insertion using the level order traversal approach, following the algorithm we discussed earlier. The `levelOrderTraversal()` function prints the level order traversal of the binary tree. Finally, in the `main()` function, we create the root node and perform insertions to demonstrate the level order insertion. Finally, we print the level order traversal of the tree.

Conclusion
In this article, we explored the concept of inserting nodes into a binary tree using level order traversal in C. We discussed the algorithm, provided a step-by-step implementation guide, and explained the underlying logic behind each step. Understanding binary tree insertion is crucial for various applications and algorithms that rely on efficient data organization. By following the techniques described in this article, you can confidently perform insertion in binary trees using level order traversal in your C programs.

Q1: What is the purpose of level order traversal in binary tree insertion?
Level order traversal ensures that the binary tree is traversed in a breadth-first manner, visiting each level before moving to the next. This approach is used to maintain the structure and balance of the tree while inserting new nodes.

Q2: How is level order insertion different from other insertion methods in binary trees?
Level order insertion ensures that new nodes are added at the first available position in the tree, starting from the leftmost node of the deepest level. This approach helps maintain a balanced tree structure and allows efficient utilization of available space.

Q3: Can level order insertion be used for binary trees with more than two children per node?
No, level order insertion is specifically designed for binary trees with a maximum of two children per node. If the tree has more than two children per node, a different approach, such as a multiway tree or an n-ary tree, should be considered.

Q4: Is it possible to insert nodes in a binary tree without using level order traversal?
Yes, there are other methods of inserting nodes in a binary tree, such as recursive insertion (using pre-order, in-order, or post-order traversal) or using specific rules based on the node’s value. However, level order insertion provides a systematic approach to maintaining balance and utilizing available space effectively.

Q5: Are there any limitations or potential issues with level order insertion in binary trees?
Level order insertion works efficiently in most scenarios, but it may face challenges when dealing with large binary trees or limited memory resources. In such cases, alternative data structures like balanced binary search trees or B-trees might be more suitable to ensure optimal performance. Additionally, level order insertion assumes a binary tree data structure and cannot be directly applied to other tree types.