Question

Please Only use C language

In this assignment, you have to read a text file (in.txt) that contains a set of words. The first line of the file contains 3 numbers (N, S, D). These numbers represent the sequence of input words in your file.

N: represents the number of words to read to build a binary search tree. You have to write a recursive insert code to create and insert these words into the binary search tree. After inserting all the items, you should show the words in Pre-order In order, and Post order. So, you need to create three functions for this purpose.

S: represents the number of words to search from the tree. These S-words are placed after the first N words in the input file. You need to implement a search function that will be able to search these words in your BST.

Additionally, the search words will also be used to look in the binary search tree and count number of words in the tree that come before the search word, alphabetically. You will need to create a recursive function with the following prototype CountBefore(treeNode* root, char searchKey[]), where treeNode is the node structure of your tree.

D: represents the number of words to delete from the BST. This list of words are placed after N+words in the input file. Write a recursive delete function for your task. After deleting all the items, also show the tree in three different orders of traversals.

Answer 1

Program screenshot:

Input file: in.txt

Sample output:

Code to copy:

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#define MAX 20
//define a node structure of the tree
struct treeNode
{
   //declare the variable and pointers.
   char word[MAX];
   struct treeNode *leftChild;  
   struct treeNode *rightChild;
}*node;

//definition of the function searchWord()
void searchWord(char word[], struct treeNode **parent, struct treeNode **position)
{
   struct treeNode *ptr, *tempPtr;
   // Checks if root node is null
   if (node == NULL)
   {
       *position = NULL;
       *parent = NULL;
       return;
   }
   //if the word is equal to root node word
   //the word is present at root node
   if (strcmp(word, node->word) == 0)
   {
       *position = node;
       *parent = NULL;
       return;
   }
   //if word is less than the root node word
   // then make ptr to left child
   if (strcmp(word, node->word) < 0)
       ptr = node->leftChild;
   // Otherwise make ptr to left child
   else
       ptr = node->rightChild;

   tempPtr = node;
   //iterate the tree
   while (ptr != NULL)
   {
       //compare the word with tree word
       //if equal make the parent as tempPtr
       if (strcmp(word, ptr->word) == 0)
       {
           *position = ptr;
           *parent = tempPtr;
           return;
       }
       tempPtr = ptr;
       //if word is less than the root node word
       // then make ptr to left child
       if (strcmp(word, ptr->word) <= 0)
           ptr = ptr->leftChild;
       else
           // Otherwise make ptr to left child
           ptr = ptr->rightChild;
   }
   *position = NULL;
   *parent = tempPtr;
}
//definition of the function insertWord()
void insertWord(char word[])
{
   struct treeNode *parent, *position, *temp;
   //call the function searchWord to check is word is present in tree
   searchWord(word, &parent, &position);
   //if the position is not null then the word is present.
   if (position != NULL)
   {
       printf("The word already present in BST.");
       return;
   }
   //create memory for the treeNode pointer
   temp = (struct treeNode*) malloc(sizeof(struct treeNode));
   //copy the word
   strcpy(temp->word, word);
   //make left and right child of temp as null
   temp->leftChild = NULL;
   temp->rightChild = NULL;
   //if the parent is null make the root node as temp
   if (parent == NULL)
       node = temp;
   else
       //if word is less than the parent word
       // then make parent's left child as temp
       if (strcmp(word, parent->word) <= 0)
           parent->leftChild = temp;
       else
           // Otherwise make parent's right child as temp
           parent->rightChild = temp;
}
//definition of the function bothChildEmpty()
void bothChildEmpty(struct treeNode *parent, struct treeNode *position)
{
   //if the parent is null then the root node is null
   if (parent == NULL)
       node = NULL;
   else
       //if the position is at the left child
       //then make position of the left child as null
       if (position == parent->leftChild)
           parent->leftChild = NULL;
       else
           //otherwise make position of the right child as null
           parent->rightChild = NULL;
}
//definition of the function oneChildEmpty()
void oneChildEmpty(struct treeNode *parent, struct treeNode *position)
{
   struct treeNode *child;
   //if the position of the leftchild is not null
   //make the position of the leftchild as the child to be deleted.
   if (position->leftChild != NULL)
       child = position->leftChild;
   else
       //else, make the position of the rightchild as the child to be deleted.
       child = position->rightChild;
   //if parent is null, root is deleted
   if (parent == NULL)
       node = child;
   else
       //if position is left child's position
       //make parent of left child as child
       if (position == parent->leftChild)
           parent->leftChild = child;
       else
           //else, make parent of right child as child
           parent->rightChild = child;
}
//definition of the function noChildEmpty()
void noChildEmpty(struct treeNode *parent, struct treeNode *position)
{
   struct treeNode *ptr, *tempPtr, *next, *prev;
   tempPtr = position;
   ptr = position->rightChild;
   while (ptr->leftChild != NULL)
   {
       tempPtr = ptr;
       ptr = ptr->leftChild;
   }
   next = ptr;
   prev = tempPtr;
   if (next->leftChild == NULL && next->rightChild == NULL)
       bothChildEmpty(prev, next);
   else
       oneChildEmpty(prev, next);
   if (parent == NULL)
       node = next;
   else
       if (position == parent->leftChild)
           parent->leftChild = next;
       else
           parent->rightChild = next;
   next->leftChild = position->leftChild;
   next->rightChild = position->rightChild;
}
//definition of the function deleteWord()
int deleteWord(char word[])
{
   struct treeNode *parent, *position;
   if (node == NULL)
   {
       printf("Tree empty");
       return 0;
   }
   //call the function searchWord to check is word is present in tree
   searchWord(word, &parent, &position);
   if (position == NULL)
   {
       printf("Item not present in tree");
       return 0;
   }
   if (position->leftChild == NULL && position->rightChild == NULL)
       bothChildEmpty(parent, position);
   if (position->leftChild != NULL && position->rightChild == NULL)
       oneChildEmpty(parent, position);
   if (position->leftChild == NULL && position->rightChild != NULL)
       oneChildEmpty(parent, position);
   if (position->leftChild != NULL && position->rightChild != NULL)
       noChildEmpty(parent, position);
   printf("\n%s: deleted", position->word);
   free(position);
}

//definition of the function preOrder()
//it is the recursive function and prints the preorder of the tree
int preOrder(struct treeNode *ptr)
{
   if (node == NULL)
   {
       printf("Tree is empty");
       return 0;
   }// End of if condition
   if (ptr != NULL)
   {
       printf("%s ", ptr->word);
       preOrder(ptr->leftChild);
       preOrder(ptr->rightChild);
   }
}
//definition of the function inOrder()
//it is the recursive function and prints the inOrder of the tree
void inOrder(struct treeNode *ptr)
{
   if (node == NULL)
   {
       printf("Tree is empty");
       return;
   }
   if (ptr != NULL)
   {
       inOrder(ptr->leftChild);
       printf("%s ", ptr->word);
       inOrder(ptr->rightChild);
   }
}
//definition of the function postOrder()
//it is the recursive function and prints the postOrder of the tree
void postOrder(struct treeNode *ptr)
{
   if (node == NULL)
   {
       printf("Tree is empty");
       return;
   }
   if (ptr != NULL)
   {
       postOrder(ptr->leftChild);
       postOrder(ptr->rightChild);
       printf("%s ", ptr->word);
   }
}
void alphabetic(struct treeNode *ptr)
{
   if (ptr != NULL)
   {
       alphabetic(ptr->leftChild);
       alphabetic(ptr->rightChild);
   }
}
//definition of the the main
int main()
{
   //declare the variable
   char word[MAX];
   int numOfReadWords, numOfSearchWords, numOfDeleteWords, i;
   node = NULL;
   //create a struct variabl
   struct treeNode *position;
   // open the input file in read mode
   FILE *fin = fopen("in.txt", "r");
   //if the file not opened, then print an error message.
   if (fin == NULL)
   {
       // Display error message
       puts("Error: Could not open files");
       return 0;
   }
   //read the first line of the input file
   fscanf(fin, "%d %d %d", &numOfReadWords, &numOfSearchWords, &numOfDeleteWords);
   //read the number of words and build a binary search tree
   //using function insertWord()
   for (i = 1; i <= numOfReadWords; i++)
   {
       fscanf(fin, "%s", word);
       insertWord(word);
   }
   //print the pre-order, in-order, postorder
   printf("Pre Order: ");
   preOrder(node);
   printf("\nIn Order: ");
   inOrder(node);
   printf("\nPost Order: ");
   postOrder(node);
   printf("\n\nSearch Phase:");
   //search the words in the binary search tree
   for (i = 1; i <= numOfSearchWords; i++)
   {
       struct treeNode *temp = node;
       //read the word from the file
       fscanf(fin, "%s", word);
       int flag = 0;
       while (temp != NULL)
       {
           if (strcmp(word, temp->word) == 0)
           {
               printf("\n%s: Found.", word);
               flag = 1;
               break;
           }
           if (strcmp(word, temp->word) <= 0)
               temp = temp->leftChild;
           else
               temp = temp->rightChild;
       }
       if (flag == 0)
           printf("\n%s: Not Found.", word);
   }
   //delete the words from the tree
   printf("\n\nDelete Phase:");
   for (i = 1; i <= numOfDeleteWords; i++)
   {
       fscanf(fin, "%s", word);
       deleteWord(word);
   }
   //print the pre-order, in-order, postorder of the tree
   printf("\n\nPre Order: ");
   preOrder(node);
   printf("\nIn Order: ");
   inOrder(node);
   printf("\nPost Order: ");
   postOrder(node);
   printf("\n");
   return 0;
}