Name: Deepak rai
Rollno : 18
Batch : 1
Assignment 1. Binary Search Tree and Traversals
SET A
a) Implement a Binary search tree (BST) library (btree.h) with operations – create, search, insert,
inorder, preorder and postorder. Write a menu driven program that performs the above operations.
#include <stdio.h>
#include <stdlib.h>
typedef struct BST
{
struct BST *Lchild;
struct BST *Rchild;
int data;
} BST;
BST *create()
{
BST *temp, *root = NULL;
char ch;
int t;
printf("Enter how many nodes?: ");
int nn;
scanf(" %d", &nn);
printf("Enter data: ");
scanf("%d", &t);
root = (BST *)malloc(sizeof(BST));
root->Lchild = root->Rchild = NULL;
root->data = t;
nn = nn - 1;
for (int i = 0; i < nn; i++)
{
printf("Enter data: ");
scanf(" %d", &t);
temp = root;
while (1)
{
if (t < temp->data)
{
if (temp->Lchild == NULL)
{
BST *newnode = (BST *)malloc(sizeof(BST));
newnode->data = t;
newnode->Lchild = newnode->Rchild = NULL;
temp->Lchild = newnode;
break;
}
else
{
temp = temp->Lchild;
}
}
else if (t > temp->data)
{
if (temp->Rchild == NULL)
{
BST *newnode = (BST *)malloc(sizeof(BST));
newnode->data = t;
newnode->Lchild = newnode->Rchild = NULL;
temp->Rchild = newnode;
break;
}
else
{
temp = temp->Rchild;
}
}
else if (t == temp->data)
{
printf("Same Same\n");
break;
}
}
}
return root;
}
void insert(BST * root, int x)
{
BST *t = root;
BST *t1 = root; while (t != NULL)
{
if (x < t->data)
{
t1 = t;
t = t->Lchild;
}
else if (x > t->data)
{
t1 = t;
t = t->Rchild;
}
else if (x == t->data)
{
printf("\nSame Same\n");
break;
}
}
if (t == NULL)
{
BST *newnode = (BST *)malloc(sizeof(BST));
newnode->data = x;
newnode->Lchild = NULL;
newnode->Rchild = NULL;
if (t1->data < x)
{
t1->Rchild = newnode;
}
else if (t1->data > x)
{
t1->Lchild = newnode;
}
}
}
void search(BST * root, int x)
{
BST *t = root;
int flag = 0;
while (t != NULL)
{
if (x < t->data)
{
t = t->Lchild;
}
else if (x > t->data)
{
t = t->Rchild;
}
else if (x == t->data)
{
printf("\nFound!!\n");
flag = 1;
break;
}
}
if (flag == 0)
{
printf("\nNot Found\n");
}
}
void inorder(BST * root)
{
if (root != NULL)
{
inorder(root->Lchild);
printf("%d ", root->data);
inorder(root->Rchild);
}
}
void preorder(BST * root)
{
if (root != NULL)
{
printf("%d ", root->data);
preorder(root->Lchild);
preorder(root->Rchild);
}
}
void postorder(BST * root)
{
if (root != NULL)
{
postorder(root->Lchild);
postorder(root->Rchild);
printf("%d ", root->data);
}
}
int main() {
BST *root;
int ch , t;
while(1){
printf("\n*WELCOME*\n");
printf("\n1.create\n2.search\n3.insert\n4.inorder\n5.preorder\n6.postorder\n");
printf("\nEnter your choice: ");
scanf("%d" , &ch);
switch(ch){
case 1:
root = create();
printf("\nBST CREATED\n");
break;
case 2:
printf("\nEnter data to search: ");
scanf("%d", &t);
search(root , t);
break;
case 3:
printf("\nEnter data to insert: ");
scanf("%d" , &t);
insert(root , t);
break;
case 4:
printf("\nInorder:\n");
inorder(root);
break;
case 5:
printf("\nPreorder\n");
preorder(root);
break;
case 6:
printf("\nPostorder\n");
postorder(root);
break;
default:
printf("\nEnter valid option!!\n");
exit(0);
}
}
return 0;
}
OUTPUT:
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 1
Enter how many nodes?: 7
Enter data: 30
Enter data: 18
Enter data: 28
Enter data: 45
Enter data: 40
Enter data: 35
Enter data: 10
BST CREATED
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 2
Enter data to search: 40
Found!!
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 3
Enter data to insert: 80
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 4
Inorder:
10 18 28 30 35 40 45 80
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 5
Preorder
30 18 10 28 45 40 35 80
*WELCOME*
1.create
2.search
3.insert
4.inorder
5.preorder
6.postorder
Enter your choice: 6
Postorder
10 8 18 35 40 80 45 30
b) Write a program which uses binary search tree library and counts the total nodes and total
leaf nodes in the tree.
int count(T) – returns the total number of nodes from BST
int countLeaf(T) – returns the total number of leaf nodes from BST
#include<stdio.h>
#include<stdlib.h>
typedef struct BST{
struct BST *Lchild;
struct BST *Rchild;
int data;
}BST;
BST *create()
{
BST *temp, *root = NULL;
char ch;
int t;
printf("Enter how many nodes?: ");
int nn;
scanf(" %d", &nn);
printf("Enter data: ");
scanf("%d", &t);
root = (BST *)malloc(sizeof(BST));
root->Lchild = root->Rchild = NULL;
root->data = t;
nn = nn - 1;
for (int i = 0; i < nn; i++)
{
printf("Enter data: ");
scanf(" %d", &t);
temp = root;
while (1)
{
if (t < temp->data)
{
if (temp->Lchild == NULL)
{
BST *newnode = (BST *)malloc(sizeof(BST));
newnode->data = t;
newnode->Lchild = newnode->Rchild = NULL;
temp->Lchild = newnode;
break;
}
else
{
temp = temp->Lchild;
}
}
else if (t > temp->data)
{
if (temp->Rchild == NULL)
{
BST *newnode = (BST *)malloc(sizeof(BST));
newnode->data = t;
newnode->Lchild = newnode->Rchild = NULL;
temp->Rchild = newnode;
break;
}
else
{
temp = temp->Rchild;
}
}
else if (t == temp->data)
{
printf("Same Same\n");
break;
}
}
}
return root;
}
int count(BST *root){
if(root == NULL){
return 0;
}
return 1 + count(root->Lchild) + count(root->Rchild);
}
int count_leaf(BST *root){
int n = count(root);
n = (n / 2) ;
return n;
}
int main() {
BST *root;
int ch , t;
char c;
while(1){
printf("\n*WELCOME*\n");
printf("\n1.create\n2.count total number of nodes\n3.count toatl number of leaf nodes\n");
printf("\nEnter your choice: ");
scanf("%d" , &ch);
switch(ch){
case 1:
printf("\nCREATING BINARY SEARCH TREE\n");
root = create();
break;
case 2:
printf("\nTotal number of nodes: %d\n" , count(root));
break;
case 3:
printf("\nTotal number of leaf nodes: %d\n" , count_leaf(root));
break;
default:
printf("\nEnter valid option!!\n");
exit(0);
}
}
return 0;
}
OUTPUT:
*WELCOME*
1.create
2.count total number of nodes
3.count toatl number of leaf nodes
Enter your choice: 1
CREATING BINARY SEARCH TREE
Enter how many nodes?: 8
Enter data: 30
Enter data: 18
Enter data: 28
Enter data: 45
Enter data: 40
Enter data: 35
Enter data: 10
Enter data: 80
*WELCOME*
1.create
2.count total number of nodes
3.count toatl number of leaf nodes
Enter your choice: 2
Total number of nodes: 8
*WELCOME*
1.create
2.count total number of nodes
3.count toatl number of leaf nodes
Enter your choice: 3
Total number of leaf nodes: 4
SET B
a) Write a C program which uses Binary search tree library and implements following function
with recursion:
T copy(T) – create another BST which is exact copy of BST which is passed as parameter.
int compare(T1, T2) – compares two binary search trees and returns 1 if they are equal and 0
otherwise.
#include<stdio.h>
#include<stdlib.h>
typedef struct BST{
struct BST *Lchild;
struct BST *Rchild;
int data;
}BST;
BST *init(int x){
BST *temp = (BST*)malloc(sizeof(BST));
temp->Lchild = NULL;
temp->Rchild = NULL;
temp->data = x;
return temp;
}
void insert(BST *root , int x){
BST *t = root;
BST *t1 = root;
while(t != NULL){
if(x < t->data){
t1 = t;
t = t->Lchild;
}else if(x > t->data){
t1 = t;
t = t->Rchild;
}else if(x == t->data){
printf("\nSame Same\n"); break;
}
}
if(t == NULL){
BST *newnode = (BST*)malloc(sizeof(BST));
newnode->data = x;
newnode->Lchild = NULL;
newnode->Rchild = NULL;
if(t1->data < x){
t1->Rchild = newnode;
} else if(t1->data > x){
t1->Lchild = newnode;
}
}
}
void preorder(BST *root){
if(root != NULL){
printf("%d " , root->data);
preorder(root->Lchild);
preorder(root->Rchild);
}
}
BST *copy(BST *root){
if(root == NULL){
return NULL;
}
BST *newnode = (BST*)malloc(sizeof(BST));
newnode->data = root->data;
newnode->Lchild = copy(root->Lchild);
newnode->Rchild = copy(root->Rchild);
return newnode;
}
int compare(BST *one , BST *two){
if(one == NULL && two == NULL){
return 1;
}
if(one->data != two->data) return 0;
return ((compare(one->Lchild , two->Lchild)) && (compare(one->Rchild , two->Rchild)));
}
int main() {
BST *root = init(5);
insert(root , 3);
insert(root , 6);
preorder(root);
printf("\n");
BST *newroot = copy(root);
preorder(newroot);
printf("\n");
printf("\n%d\n" , compare(root , newroot));
return 0;
}
OUTPUT:
536
536
1 //indicates that both tree are identical
_________________________________________________________________
SET C
a) Write a C program which uses Binary search tree library and implements following two functions:
int sumodd(T) – returns sum of all odd numbers from BST
int sumeven(T) – returns sum of all even numbers from BST
mirror(T) – converts given tree into its mirror image.
#include<stdio.h>
#include<stdlib.h>
typedef struct BST{
struct BST *Lchild;
struct BST *Rchild;
int data;
}BST;
BST *init(int x){
BST *temp = (BST*)malloc(sizeof(BST));
temp->Lchild = NULL;
temp->Rchild = NULL;
temp->data = x;
return temp;
}
void insert(BST *root , int x){
BST *t = root;
BST *t1 = root;
while(t != NULL){
if(x < t->data){
t1 = t;
t = t->Lchild;
}else if(x > t->data){
t1 = t;
t = t->Rchild;
}else if(x == t->data){
printf("\nSame Same\n"); break;
}
}
if(t == NULL){
BST *newnode = (BST*)malloc(sizeof(BST));
newnode->data = x;
newnode->Lchild = NULL;
newnode->Rchild = NULL;
if(t1->data < x){
t1->Rchild = newnode;
} else if(t1->data > x){
t1->Lchild = newnode;
}
}
}
void preorder(BST *root){
if(root != NULL){
printf("%d " , root->data);
preorder(root->Lchild);
preorder(root->Rchild);
}
}
int sumOdd(BST *root){
int sum = 0;
if(root != NULL){
if((root->data % 2) != 0){
sum = sum + root->data;
}
sum = sum + sumOdd(root->Lchild);
sum = sum + sumOdd(root->Rchild);
}
return sum;
}
int sumEven(BST *root){
int sum = 0;
if(root != NULL){
if((root->data % 2) == 0){
sum = sum + root->data;
}
sum = sum + sumEven(root->Lchild);
sum = sum + sumEven(root->Rchild);
}
return sum;
}
BST *mirror(BST *root){
BST *newnode = (BST*)malloc(sizeof(BST));
if(root == NULL){
return NULL;
}
newnode->data = root->data;
newnode->Lchild = mirror(root->Rchild);
newnode->Rchild = mirror(root->Lchild);
return newnode;
}
int main() {
BST *root = init(5);
insert(root , 3);
insert(root , 6);
printf("SUM OF ODD NUMBERS:%d\n" , sumOdd(root));
printf("SUM OF EVEN NUMBERS:%d\n" , sumEven(root));
BST *newroot = mirror(root);
printf("MIRROR IMAGE NODES:");
preorder(newroot);
return 0;
}
OUTPUT:
SUM OF ODD NUMBERS:8
SUM OF EVEN NUMBERS:6
MIRROR IMAGE NODES:5 6 3
b) Write a function to delete an element from BST.
BST *succ(BST *root){
BST *current = root;
if(current->Lchild==NULL)
{
return current;
}
while(current->Lchild->Lchild != NULL)
{
current = current->Lchild;
}
BST *temp = current->Lchild;
current->Lchild = NULL;
return temp;
}
void delete(BST *root , int x){
BST *t = root;
int flag = 0;
BST *parent = root;
while((t != NULL) && (flag == 0)){
if(x < t->data){
parent = t;
t = t->Lchild;
}else if(x > t->data){
parent = t;
t = t->Rchild;
}else if(x == t->data){
flag = 1;
break;
}
}
if(flag == 0){
printf("\nNot Found!!\n");
}else{
//no child
if((t->Lchild == NULL) && (t->Rchild == NULL)){
if(parent->Lchild == t){
parent->Lchild = NULL;
}else if(parent->Rchild == t){
parent->Rchild = NULL;
}
//two child
}else if((t->Lchild != NULL) && (t->Rchild != NULL))
{
if(t->Rchild->Lchild==NULL && t->Rchild->Rchild==NULL)
{
t->data=t->Rchild->data;
free t->Rchild;
t->Rchild=NULL;
}
else
{
BST *temp = succ(t->Rchild);
t->data = temp->data;
}
}//one child
else if(parent->Lchild == t){
if(t->Lchild == NULL){
parent->Lchild = t->Rchild;
}else if(t->Rchild == NULL){
parent->Lchild = t->Lchild;
}
}else if(parent->Rchild == t){
printf("hello\n");
if(t->Lchild == NULL){
parent->Rchild = t->Rchild;
}else if(t->Rchild == NULL){
parent->Rchild = t->Lchild;
}
}
}
}
c) What modifications are required in search function to count the number of comparisons required?
int search(BST *root , int x){
BST *t = root;
int flag = 0;
int com;
while(t!=NULL){
if(x < t->data){
com++;
t = t->Lchild;
}else if(x > t->data){
com++;
t = t->Rchild;
}else if(x == t->data){
com++;
printf("\nFound!!\n");
flag = 1;
break;
}
}
if(flag == 0){
printf("\nNot Found\n");
}
return com;
}
