TITLE - Data Structures Using C, 2/e

AUTHOR - Reema Thareja

CHAPTER 10 - EFFICIENT BINARY TREES

***********************************************************************************
***********************

1. Write a program to create a binary search tree and perform all the operations
discussed
in the preceding sections.
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
struct node
{
int data;
struct node *left;
struct node *right;
};
struct node *tree;
void create_tree(struct node *);
struct node *insertElement(struct node *, int);
void preorderTraversal(struct node *);
void inorderTraversal(struct node *);
void postorderTraversal(struct node *);
struct node *findSmallestElement(struct node *);
struct node *findLargestElement(struct node *);
struct node *deleteElement(struct node *, int);
struct node *mirrorImage(struct node *);
int totalNodes(struct node *);
int totalExternalNodes(struct node *);
int totalInternalNodes(struct node *);
int Height(struct node *);
struct node *deleteTree(struct node *);
int main()
{
int option, val;
struct node *ptr;
create_tree(tree);
clrscr();
do
{
printf("\n ******MAIN MENU******* \n");
printf("\n 1. Insert Element");
printf("\n 2. Preorder Traversal");
printf("\n 3. Inorder Traversal");
printf("\n 4. Postorder Traversal");
printf("\n 5. Find the smallest element");
printf("\n 6. Find the largest element");
printf("\n 7. Delete an element");
printf("\n 8. Count the total number of nodes");
printf("\n 9. Count the total number of external nodes");
printf("\n 10. Count the total number of internal nodes");
printf("\n 11. Determine the height of the tree");
printf("\n 12. Find the mirror image of the tree");
printf("\n 13. Delete the tree");
printf("\n 14. Exit");
printf("\n\n Enter your option : ");
scanf("%d", &option);
switch(option)
{
case 1:
printf("\n Enter the value of the new node : ");
scanf("%d", &val);
tree = insertElement(tree, val);
break;
case 2:
printf("\n The elements of the tree are : \n");
preorderTraversal(tree);
break;
case 3:
printf("\n The elements of the tree are : \n");
inorderTraversal(tree);
break;
case 4:
printf("\n The elements of the tree are : \n");
postorderTraversal(tree);
break;
case 5:
ptr = findSmallestElement(tree);
printf("\n Smallest element is :%d",ptr�>data);
break;
case 6:
ptr = findLargestElement(tree);
printf("\n Largest element is : %d", ptr�>data);
break;
case 7:
printf("\n Enter the element to be deleted : ");
scanf("%d", &val);
tree = deleteElement(tree, val);
break;
case 8:
printf("\n Total no. of nodes = %d", totalNodes(tree));
break;
case 9:
printf("\n Total no. of external nodes = %d",
totalExternalNodes(tree));
break;
case 10:
printf("\n Total no. of internal nodes = %d",
totalInternalNodes(tree));
break;
case 11:
printf("\n The height of the tree = %d",Height(tree));
break;
case 12:
tree = mirrorImage(tree);
break;
case 13:
tree = deleteTree(tree);
break;
}
}while(option!=14);
getch();
return 0;
}
void create_tree(struct node *tree)
{
tree = NULL;
}
struct node *insertElement(struct node *tree, int val)
{
struct node *ptr, *nodeptr, *parentptr;
ptr = (struct node*)malloc(sizeof(struct node));
ptr�>data = val;
ptr�>left = NULL;
ptr�>right = NULL;
if(tree==NULL)
{
tree=ptr;
tree�>left=NULL;
tree�>right=NULL;
}
else
{
parentptr=NULL;
nodeptr=tree;
while(nodeptr!=NULL)
{
parentptr=nodeptr;
if(val<nodeptr�>data)
nodeptr=nodeptr�>left;
else
nodeptr = nodeptr�>right;
}
if(val<parentptr�>data)
parentptr�>left = ptr;
else
parentptr�>right = ptr;
}
return tree;
}
void preorderTraversal(struct node *tree)
{
if(tree != NULL)
{
printf("%d\t", tree�>data);
preorderTraversal(tree�>left);
preorderTraversal(tree�>right);
}
}
void inorderTraversal(struct node *tree)
{
if(tree != NULL)
{
inorderTraversal(tree->left);
printf("%d\t", tree->data);
inorderTraversal(tree->right);
}
}
void postorderTraversal(struct node *tree)
{
if(tree != NULL)
{
postorderTraversal(tree->left);
postorderTraversal(tree->right);
printf("%d\t", tree->data);
}
}
struct node *findSmallestElement(struct node *tree)
{
if( (tree == NULL) || (tree->left == NULL))
return tree;
else
return findSmallestElement(tree ->left);
}
struct node *findLargestElement(struct node *tree)
{
if( (tree == NULL) || (tree->right == NULL))
return tree;
else
return findLargestElement(tree->right);
}
struct node *deleteElement(struct node *tree, int val)
{
struct node *cur, *parent, *suc, *psuc, *ptr;
if(tree�>left==NULL)
{
printf("\n The tree is empty ");
return(tree);
}
parent = tree;
cur = tree�>left;
while(cur!=NULL && val!= cur�>data)
{
parent = cur;
cur = (val<cur�>data)? cur�>left:cur�>right;
}
if(cur == NULL)
{
printf("\n The value to be deleted is not present in the tree");
return(tree);
}
if(cur�>left == NULL)
ptr = cur�>right;
else if(cur�>right == NULL)
ptr = cur�>left;
else
{
// Find the in�order successor and its parent
psuc = cur;
cur = cur�>left;
while(suc�>left!=NULL)
{
psuc = suc;
suc = suc�>left;
}
if(cur==psuc)
{
// Situation 1
suc�>left = cur�>right;
}
else
{
// Situation 2
suc�>left = cur�>left;
psuc�>left = suc�>right;
suc�>right = cur�>right;
}
ptr = suc;
}
// Attach ptr to the parent node
if(parent�>left == cur)
parent�>left=ptr;
else
parent�>right=ptr;
free(cur);
return tree;
}
int totalNodes(struct node *tree)
{
if(tree==NULL)
return 0;
else
return(totalNodes(tree�>left) + totalNodes(tree�>right) + 1);
}
int totalExternalNodes(struct node *tree)
{
if(tree==NULL)
return 0;
else if((tree�>left==NULL) && (tree�>right==NULL))
return 1;
else
return (totalExternalNodes(tree�>left) +
totalExternalNodes(tree�>right));
}
int totalInternalNodes(struct node *tree)
{
if( (tree==NULL) || ((tree�>left==NULL) && (tree�>right==NULL)))
return 0;
else
return (totalInternalNodes(tree�>left)
+ totalInternalNodes(tree�>right) + 1);
}
int Height(struct node *tree)
{
int leftheight, rightheight;
if(tree==NULL)
return 0;
else
{
leftheight = Height(tree�>left);
rightheight = Height(tree�>right);
if(leftheight > rightheight)
return (leftheight + 1);
else
return (rightheight + 1);
}
}
struct node *mirrorImage(struct node *tree)
{
struct node *ptr;
if(tree!=NULL)
{
mirrorImage(tree�>left);
mirrorImage(tree�>right);
ptr=tree�>left;
ptr�>left = ptr�>right;
tree�>right = ptr;
}
}
struct node *deleteTree(struct node *tree)
{
if(tree!=NULL)
{
deleteTree(tree�>left);
deleteTree(tree�>right);
free(tree);
}
}

***********************************************************************************
*************************

2. Write a program to implement simple right in-threaded binary trees.

#include <stdio.h>
#include <conio.h>
struct tree
{
int val;
struct tree *right;
struct tree *left;
int thread;
};
struct tree *root = NULL;
struct tree* insert_node(struct tree *root, struct tree *ptr, struct tree *rt)
{
if(root == NULL)
{
root = ptr;
if(rt != NULL)
{
root�>right = rt;
root�>thread = 1;
}
}
else if(ptr�>val < root�>val)
root�>left = insert_node(root�>left, ptr, root);
else
if(root�>thread == 1)
{
root�>right = insert_node(NULL, ptr, rt);
root�>thread=0;
}
else
root�>right = insert_node(root�>right, ptr, rt);
return root;
}
struct tree* create_threaded_tree()
{
struct tree *ptr;
int num;
printf("\n Enter the elements, press �1 to terminate ");
scanf("%d", &num);
while(num != �1)
{
ptr = (struct tree*)malloc(sizeof(struct tree));
ptr�>val = num;
ptr�>left = ptr�>right = NULL;
ptr�>thread = 0;
root = insert_node(root, ptr, NULL);
printf(" \n Enter the next element ");
fflush(stdin);
scanf("%d", &num);
}
return root;
}
void inorder(struct tree *root)
{
struct tree *ptr = root, *prev;
do
{
while(ptr != NULL)
{
prev = ptr;
ptr = ptr�>left;
}
if(prev != NULL)
{
printf(" %d", prev�>val);
ptr = prev�>right;
while(prev != NULL && prev�>thread)
{
printf(" %d", ptr�>val);
prev = ptr;
ptr = ptr�>right;
}
}
}while(ptr != NULL);
}
void main()
{
// struct tree *root=NULL;
clrscr();
create_threaded_tree();
printf(" \n The in�order traversal of the tree can be given as : ");
inorder(root);
getch();
}

***********************************************************************************
***********************

3. Write a program that shows insertion operation in an AVL tree.

#include <stdio.h>
typedef enum { FALSE ,TRUE } bool;
struct node
{
int val;
int balance;
struct node *left_child;
struct node *right_child;
};
struct node* search(struct node *ptr, int data)
{
if(ptr!=NULL)
if(data < ptr -> val)
ptr = search(ptr -> left_child,data);
else if( data > ptr -> val)
ptr = search(ptr -> right_child, data);
return(ptr);
}
struct node *insert (int data, struct node *ptr, int *ht_inc)
{
struct node *aptr;
struct node *bptr;
if(ptr==NULL)
{
ptr = (struct node *) malloc(sizeof(struct node));
ptr -> val = data;
ptr -> left_child = NULL;
ptr -> right_child = NULL;
ptr -> balance = 0;
*ht_inc = TRUE;
return (ptr);
}
if(data < ptr -> val)
{
ptr -> left_child = insert(data, ptr -> left_child, ht_inc);
if(*ht_inc==TRUE)
{
switch(ptr -> balance)
{
case -1: /* Right heavy */
ptr -> balance = 0;
*ht_inc = FALSE;
break;
case 0: /* Balanced */
ptr -> balance = 1;
break;
case 1: /* Left heavy */
aptr = ptr -> left_child;
if(aptr -> balance == 1)
{
printf(�Left to Left Rotation\n�);
ptr -> left_child= aptr -> right_child;
aptr -> right_child = ptr;
ptr -> balance = 0;
aptr -> balance=0;
ptr = aptr;
}
else
{
printf(�Left to right rotation\n�);
bptr = aptr -> right_child;
aptr -> right_child = bptr -> left_child;
bptr -> left_child = aptr;
ptr -> left_child = bptr -> right_child;
bptr -> right_child = ptr;
if(bptr -> balance == 1 )
ptr -> balance = -1;
else
ptr -> balance = 0;
if(bptr -> balance == -1)
aptr -> balance = 1;
else
aptr -> balance = 0;
bptr -> balance=0;
ptr = bptr;
}
*ht_inc = FALSE;
}
}
}
if(data > ptr -> val)
{
ptr -> right_child = insert(info, ptr -> right_child, ht_inc);
if(*ht_inc==TRUE)
{
switch(ptr -> balance)
{
case 1: /* Left heavy */
ptr -> balance = 0;
*ht_inc = FALSE;
break;
case 0: /* Balanced */
ptr -> balance = -1;
break;
case -1: /* Right heavy */
aptr = ptr -> right_child;
if(aptr -> balance == -1)
{
printf(�Right to Right Rotation\n�);
ptr -> right_child= aptr -> left_child;
aptr -> left_child = ptr;
ptr -> balance = 0;
aptr -> balance=0;
ptr = aptr;
}
else
{
printf(�Right to Left Rotation\n�);
bptr = aptr -> left_child;
aptr -> left_child = bptr -> right_child;
bptr -> right_child = aptr;
ptr -> right_child = bptr -> left_child;
bptr -> left_child = pptr;
if(bptr -> balance == -1)
ptr -> balance = 1;
else
ptr -> balance = 0;
if(bptr -> balance == 1)
aptr -> balance = -1;
else
aptr -> balance = 0;
bptr -> balance=0;
ptr = bptr;
}/*End of else*/
*ht_inc = FALSE;
}
}
}
return(ptr);
}
void display(struct node *ptr, int level)
{
int i;
if ( ptr!=NULL )
{
display(ptr -> right_child, level+1);
printf(�\n�);
for (i = 0; i < level; i++)
printf(� �);
printf(�%d�, ptr -> val);
display(ptr -> left_child, level+1);
}
}
void inorder(struct node *ptr)
{
if(ptr!=NULL)
{
inorder(ptr -> left_child);
printf(�%d �,ptr -> val);
inorder(ptr -> right_child);
}
}
main()
{
bool ht_inc;
int data ;
int option;
struct node *root = (struct node *)malloc(sizeof(struct node));
root = NULL;
while(1)
{
printf(�1.Insert\n�);
printf(�2.Display\n�);
printf(�3.Quit\n�);
printf(�Enter your option : �);
scanf(�%d�,&option);
switch(choice)
{
case 1:
printf(�Enter the value to be inserted : �);
scanf(�%d�, &data);
if( search(root,data) == NULL )
root = insert(data, root, &ht_inc);
else
printf(�Duplicate value ignored\n�);
break;
case 2:
if(root==NULL)
{
printf(�Tree is empty\n�);
continue;
}
printf(�Tree is :\n�);
display(root, 1);
printf(�\n\n�);
printf(�Inorder Traversal is: �);
inorder(root);
printf(�\n�);
break;
case 3:
exit(1);
default:
printf(�Wrong option\n�);
}
}
}

***********************************************************************************
**************************