Question

Write a program, called wordcount.c, that reads one word at a time
from the standard input. It keeps track of the words read and the
number of occurrences of each word. When it encounters the end of
input, it prints the most frequently occurring word and its count.
The following screenshot shows the program in action:

adminuser@adminuser-VirtualBox~/Desktop/HW8 $ wordCount This is a
sample. Is is most frequent, although punctuation and capitals are treated as part of the word. this is so.

The most frequent word is "is", which appears 3 times. adminuser@adminuser-virtualbox ~/Desktop/HW8 $ wordCount < mobydick.txt

The most frequest word is "the", which appears 13666 times

The first time I called wordcount, I entered two lines of text as input,
followed by a <CTRL-D>. (When entering text from the keyboard, typing <CTRL-D> at
the beginning of a line signals end-of-input.) The line beginning
"The most frequent word..." is the output. The second time I called
the program, I used redirection (<) to have the file
mobydick.txt be treated as the standard input.

Your program should consider a "word" to be a sequence of non-blank characters, as
retrieved by the "%s" format in scanf. No need to remove
punctuation or turn uppercase letters into lower-case ones. For
example, "is", "Is", and "is." are all different words.

Your program should store the word information in a binary search tree.
The file bst.h gives the definitions of the BSTnode structure, and
defines some functions you should implement. In particular, a node
contains a pointer to an item, plus a pointer to the left and right
child nodes. The item is a (void *) pointer, which means that the
node is able to store anything. You should write a file bst.c to
implement these functions.

The program wordcount.c will use a BST that has one node in the tree for each distinct word. The item for
the node should be a pointer to a WordCount structure, defined as follows:

struct wordcount {

char word[80];

int count;

};

typedef struct wordcount WordCount;

bst.h provided below // bst.h:
Functions to support binary search trees #ifndef BST_H #define
BST_H struct bstnode { void *item; struct bstnode *left; struct
bstnode *right; }; typedef struct bstnode BSTnode; // Create a new
node having the specified item. BSTnode *createNode(void *item); //
Search the tree rooted at node n for the node matching the
specified item. // If the item exists, return its node. If not,
return the node that would be its parent. // The function "compare"
compares items. BSTnode *find(BSTnode *n, void *item, int
compare(void *, void *)); // Insert an item into the tree rooted at
node n. // If the tree already has a node for that item, do
nothing. void insert(BSTnode *n, void *item, int compare(void *,
void *)); #endif Show transcribed image text

Answer 1

#include <stdio.h>
#include <string.h>
#include <ctype.h>
# define MAX_CHARS 26
# define MAX_WORD_SIZE 30
struct TrieNode
{
bool isEnd;
unsigned frequency;
int indexMinHeap;
TrieNode* child[MAX_CHARS];
};
struct MinHeapNode
{
TrieNode* root;
unsigned frequency;
char* word;
};
struct MinHeap
{
unsigned capacity;
int count;
MinHeapNode* array;
};
TrieNode* newTrieNode()
{
TrieNode* trieNode = new TrieNode;
trieNode->isEnd = 0;
trieNode->frequency = 0;
trieNode->indexMinHeap = -1;
for( int i = 0; i < MAX_CHARS; ++i )
trieNode->child[i] = NULL;
return trieNode;
}
MinHeap* createMinHeap( int capacity )
{
MinHeap* minHeap = new MinHeap;
minHeap->capacity = capacity;
minHeap->count =0;
minHeap->array = new MinHeapNode [ minHeap->capacity ];
return minHeap;
}
void swapMinHeapNodes ( MinHeapNode* a, MinHeapNode* b )
{
MinHeapNode temp = *a;
*a = *b;
*b = temp;
}
void minHeapify( MinHeap* minHeap, int idx )
{
int left, right, smallest;
left = 2 * idx + 1;
right = 2 * idx + 2;
smallest = idx;
if ( left < minHeap->count && minHeap->array[ left ]. frequency < minHeap->array[ smallest ]. frequency)
smallest = left;
if ( right < minHeap->count && minHeap->array[ right ]. frequency < minHeap->array[ smallest ]. frequency)
smallest = right;
if( smallest != idx )
{
minHeap->array[ smallest ]. root->indexMinHeap = idx;
minHeap->array[ idx ]. root->indexMinHeap = smallest;
swapMinHeapNodes (&minHeap->array[ smallest ], &minHeap->array[ idx ]);
minHeapify( minHeap, smallest );
}
}
void buildMinHeap( MinHeap* minHeap )
{
int n, i;
n = minHeap->count - 1;
for( i = ( n - 1 ) / 2; i >= 0; --i )
minHeapify( minHeap, i );
}
void insertInMinHeap( MinHeap* minHeap, TrieNode** root, const char* word )
{
if( (*root)->indexMinHeap != -1 )
{
++( minHeap->array[ (*root)->indexMinHeap ]. frequency );
minHeapify( minHeap, (*root)->indexMinHeap );
}
else if( minHeap->count < minHeap->capacity )
{
int count = minHeap->count;
minHeap->array[ count ]. frequency = (*root)->frequency;
minHeap->array[ count ]. word = new char [strlen( word ) + 1];
strcpy( minHeap->array[ count ]. word, word );
minHeap->array[ count ]. root = *root;
(*root)->indexMinHeap = minHeap->count;
++( minHeap->count );
buildMinHeap( minHeap );
}
else if ( (*root)->frequency > minHeap->array[0]. frequency )
{
minHeap->array[ 0 ]. root->indexMinHeap = -1;
minHeap->array[ 0 ]. root = *root;
minHeap->array[ 0 ]. root->indexMinHeap = 0;
minHeap->array[ 0 ]. frequency = (*root)->frequency;
delete [] minHeap->array[ 0 ]. word;
minHeap->array[ 0 ]. word = new char [strlen( word ) + 1];
strcpy( minHeap->array[ 0 ]. word, word );
minHeapify ( minHeap, 0 );
}
}
void insertUtil ( TrieNode** root, MinHeap* minHeap,const char* word, const char* dupWord )
{
if ( *root == NULL )
*root = newTrieNode();
if ( *word != '\0' )
insertUtil ( &((*root)->child[ tolower( *word ) - 97 ]), minHeap, word + 1, dupWord );
else
{
if ( (*root)->isEnd )
++( (*root)->frequency );
else
{
(*root)->isEnd = 1;
(*root)->frequency = 1;
}
insertInMinHeap( minHeap, root, dupWord );
}
}
void insertTrieAndHeap(const char *word, TrieNode** root, MinHeap* minHeap)
{
insertUtil( root, minHeap, word, word );
}
void displayMinHeap( MinHeap* minHeap )
{
int i;
for( i = 0; i < minHeap->count; ++i )
{
printf( "%s : %d\n", minHeap->array[i].word,minHeap->array[i].frequency );
}
}
void printKMostFreq( FILE* fp, int k )
{
MinHeap* minHeap = createMinHeap( k );
TrieNode* root = NULL;
char buffer[MAX_WORD_SIZE];
while( fscanf( fp, "%s", buffer ) != EOF )
insertTrieAndHeap(buffer, &root, minHeap);
displayMinHeap( minHeap );
}
int main()
{
int k = 5;
FILE *fp = fopen ("HomeworkLib.txt", "r"); //you can create HomeworkLib.txt file in that we give input
if (fp == NULL)
printf ("File doesn't exist ");
else
printKMostFreq (fp, k);
return 0;
}