Lab Manual
Lab Manual
Construct an AVL tree for a given set of elements which are stored in a file. And
implement insert and delete operation on the constructed tree. Write contents of tree into
a new file using in-order.
#include <stdio.h>
#include <stdlib.h>
struct TreeNode {
int data;
};
if (node == NULL)
return 0;
return node->height;
return (a > b) ? a : b;
}
if (newNode != NULL) {
newNode->data = key;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
return x;
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
return y;
return 0;
if (root == NULL)
return createNode(key);
return root;
// Get the balance factor to check whether this node became unbalanced
return rightRotate(root);
return leftRotate(root);
root->left = leftRotate(root->left);
return rightRotate(root);
root->right = rightRotate(root->right);
return leftRotate(root);
return root;
current = current->left;
return current;
if (root == NULL)
return root;
else {
// No child case
if (temp == NULL) {
temp = root;
root = NULL;
} else // One child case
free(temp);
} else {
root->data = temp->data;
if (root == NULL)
return root;
// Get the balance factor to check whether this node became unbalanced
return rightRotate(root);
root->left = leftRotate(root->left);
return rightRotate(root);
return leftRotate(root);
root->right = rightRotate(root->right);
return leftRotate(root);
return root;
}/
if (root != NULL) {
inOrderTraversal(root->left);
inOrderTraversal(root->right);
if (root != NULL) {
freeAVLTree(root->left);
freeAVLTree(root->right);
free(root);
int main() {
do {
printf("4. Exit\n");
scanf("%d", &choice);
switch (choice) {
case 1:
scanf("%d", &key);
break;
case 2:
scanf("%d", &key);
break;
case 3:
inOrderTraversal(root);
printf("\n");
break;
case 4:
freeAVLTree(root);
printf("Exiting...\n");
break;
default:
return 0;
Output:
[?2004l
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
Enter your choice: 1
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
In-order Traversal: 2 4 5 11 20 32 40
AVL Tree Operations:
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
In-order Traversal: 4 5 11 20 32 40
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
In-order Traversal: 5 11 20 32 40
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
In-order Traversal: 5 11 20 40
2. Delete a node
3. In-order Traversal
4. Exit
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
In-order Traversal: 5 20 40
1. Insert a node
2. Delete a node
3. In-order Traversal
4. Exit
Exiting...
Week 2
2.Construct B-Tree an order of 5 with a set of 100 random elements stored in array. Implement
searching, insertion and deletion operations.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
struct BTreeNode {
};
if (newNode == NULL) {
exit(EXIT_FAILURE);
newNode->num_keys = 0;
newNode->is_leaf = is_leaf;
newNode->children[i] = NULL;
return newNode;
}
// Function to split a full child node
newNode->num_keys = M/2 - 1;
if (!child->is_leaf) {
child->num_keys = M/2 - 1;
parent->children[i + 1] = parent->children[i];
}
parent->children[index + 1] = newNode;
// Shift parent's keys to insert the middle key from the child
parent->keys[i + 1] = parent->keys[i];
parent->num_keys++;
int i = node->num_keys - 1;
if (node->is_leaf) {
node->keys[i + 1] = node->keys[i];
i--;
node->keys[i + 1] = key;
node->num_keys++;
} else {
i--;
i++;
if (node->children[i]->num_keys == M - 1) {
splitChild(node, i);
i++;
insertNonFull(node->children[i], key);
if (node == NULL) {
*root = createNode(true);
(*root)->keys[0] = key;
(*root)->num_keys = 1;
} else {
if (node->num_keys == M - 1) {
new_root->children[0] = node;
splitChild(new_root, 0);
*root = new_root;
insertNonFull(*root, key);
if (root != NULL) {
int i;
traverse(root->children[i]);
traverse(root->children[i]);
}
// Main function to test B-tree implementation
int main() {
insert(&root, 10);
insert(&root, 20);
insert(&root, 5);
insert(&root, 6);
insert(&root, 12);
insert(&root, 30);
traverse(root);
printf("\n");
return 0;
OUTPUT: