words_alphabetical.c File Reference

Printing the words contained in a file named file.txt in alphabetical order and also their frequencies in to another file "wordcount.txt". More...

#include <assert.h>
#include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for words_alphabetical.c:

Data Structures
struct	Node
	Node, the basic data structure of the tree. More...

Functions
void	endProgramAbruptly (char *errorMessage)
	Ends program due to an error. More...
void	freeTreeMemory (struct Node *node)
	Frees memory when program is terminating. More...
char *	getPointerToWord (char *word)
	Stores word in memory. More...
void	closeFile (FILE *file)
	Closes the file after reading or writing. More...
struct Node *	allocateMemoryForNode ()
	Reserves memory for new node. More...
void	writeContentOfTreeToFile (struct Node *node, FILE *file)
	Writes contents of tree to another file alphabetically. More...
struct Node *	addWordToTree (char *word, struct Node *currentNode)
	Adds word (node) to the correct position in tree. More...
struct Node *	readWordsInFileToTree (FILE *file, struct Node *root)
	Reads words from file to tree. More...
static void	test ()
	Self-test implementations. More...
int	main ()
	Main function. More...

Detailed Description

Printing the words contained in a file named file.txt in alphabetical order and also their frequencies in to another file "wordcount.txt".

Given a file (file.txt) containing words (like a publication or a novel), where words are separated by a space, newline, or underscore. This program prints (writes or outputs) to another file (wordcount.txt), the individual words contained in 'file.txt' with their frequencies (number of occurrences) each on a newline and in alphabetical order. This program uses the binary tree data structure to accomplish this task.

Author

Randy Kwalar

Function Documentation

addWordToTree()

struct Node * addWordToTree	(	char *	word,
		struct Node *	currentNode
	)

Adds word (node) to the correct position in tree.

Parameters

word	word to be inserted in to the tree
currentNode	node which is being compared

Returns

a pointer to the root node

< holds compare state

{
    if (currentNode == NULL)  // checks if `currentNode` is `NULL`
    {
        struct Node *currentNode =
            allocateMemoryForNode();  // allocates memory for new node
        currentNode->word = getPointerToWord(word);  // stores `word` in memory
        currentNode->frequency = 1;  // initializes the word frequency to 1
        currentNode->left = NULL;    // sets left node to `NULL`
        currentNode->right = NULL;   // sets right node to `NULL`
        return currentNode;          // returns pointer to newly created node
    }
 
    int64_t compared = strcmp(word, currentNode->word);  ///< holds compare state
 
    if (compared > 0) {
        currentNode->right = addWordToTree(word,
            currentNode->right);  // adds `word` to right sub tree if `word` is
                                  // alphabetically greater than `currentNode->word`
    }
    else if (compared < 0) {
        currentNode->left = addWordToTree(word,
            currentNode->left);  // adds `word` to left sub tree if `word` is
                                 // alphabetically less than `currentNode->word`
    }
    else {
        currentNode->frequency++; // increments `currentNode` frequency if `word` is the same as `currentNode->word`
    }
 
    return currentNode; // returns pointer to current node
}

Here is the call graph for this function:

allocateMemoryForNode()

struct Node * allocateMemoryForNode

(

)

Reserves memory for new node.

Returns

a pointer to the newly allocated node if memory IS successfully reserved

NULL if memory is NOT reserved

< pointer to the node

{
    struct Node *node =
        (struct Node *)malloc(sizeof(struct Node));  ///< pointer to the node
    if (node != NULL)
    {
        return node;
    }
    endProgramAbruptly(
        "\nA problem occurred while reserving memory for the structure\n");
    return NULL;
}

Here is the call graph for this function:

closeFile()

void closeFile

(

FILE *

file

)

Closes the file after reading or writing.

Parameters

file	pointer to the file to be closed

Returns

void

{
    if (fclose(file)) {
        endProgramAbruptly("\nA Problem Occurred while closing a file\n");
     }
}

Here is the call graph for this function:

endProgramAbruptly()

void endProgramAbruptly

(

char *

errorMessage

)

Ends program due to an error.

Parameters

errorMessage

the error message to be printed

Returns

void

{
    fprintf(stderr, "%s\n", errorMessage);
    exit(EXIT_FAILURE);
}

freeTreeMemory()

void freeTreeMemory

(

struct Node *

node

)

Frees memory when program is terminating.

Parameters

node	pointer to current node

Returns

void

{
    if (node != NULL)
    {
        freeTreeMemory(node->left);
        freeTreeMemory(node->right);
        free(node->word);  // freeing node->word because memory was allocated
                           // using malloc
        free(node);  // freeing node because memory was allocated using malloc
    }
}

Here is the call graph for this function:

getPointerToWord()

char * getPointerToWord

(

char *

word

)

Stores word in memory.

Parameters

word	word to be stored in memory

Returns

a pointer to the newly allocated word if the word IS stored successfully

NULL if the word is NOT stored

< pointer to string

{
    char *string =
        (char *)malloc((strlen(word) + 1) * sizeof(char));  ///< pointer to string
    // + 1 is for the '\0' character
    if (string != NULL)
    {
        strcpy(string, word);
        return string;
    }
    endProgramAbruptly(
        "\nA problem occurred while reserving memory for the word\n");
    return NULL;
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

{
    test();  // run self-test implementations
    return 0;
}

Here is the call graph for this function:

readWordsInFileToTree()

struct Node * readWordsInFileToTree	(	FILE *	file,
		struct Node *	root
	)

Reads words from file to tree.

Parameters

file	file to be read from
root	root node of tree

Returns

a pointer to the root node

< pointer to the input string

< temp storage of characters

< bool to mark the end of a word

< position in inputString to place the inputChar

{
    // longest english word = 45 chars
    // +1 for '\0' = 46 chars
    char *inputString =
        (char *)malloc(46 * sizeof(char));  ///< pointer to the input string
 
    char inputChar;                ///< temp storage of characters
    bool isPrevCharAlpha = false;  ///< bool to mark the end of a word
    uint8_t pos = 0;  ///< position in inputString to place the inputChar
 
    while ((inputChar = fgetc(file)) != EOF)
    {
        if (pos > 0)
            isPrevCharAlpha = isalpha(inputString[pos - 1]);
 
        // checks if character is letter
        if (isalpha(inputChar))
        {
            inputString[pos++] = tolower(inputChar);
            continue;
        }
 
        // checks if character is ' or - and if it is preceded by a letter eg
        // yours-not, persons' (valid)
        if ((inputChar == '\'' || inputChar == '-') && isPrevCharAlpha)
        {
            inputString[pos++] = inputChar;
            continue;
        }
 
        // makes sure that there is something valid in inputString
        if (pos == 0)
            continue;
 
        // if last character is not letter and is not ' then replace by \0
        if (!isPrevCharAlpha && inputString[pos - 1] != '\'')
            pos--;
        inputString[pos] = '\0';
        pos = 0;
        isPrevCharAlpha = false;
        root = addWordToTree(inputString, root);
    }
 
    // this is to catch the case for the EOF being immediately after the last
    // letter or '
    if (pos > 0)
    {
        if (!isPrevCharAlpha && inputString[pos - 1] != '\'')
            pos--;
        inputString[pos] = '\0';
        root = addWordToTree(inputString, root);
    }
 
    free(inputString);
    return root;
}

Here is the call graph for this function:

test()

static void test ( void  )

static

Self-test implementations.

Returns

void

< pointer to the root node

< pointer to the file

{
    struct Node *root = NULL;  ///< pointer to the root node
    FILE *file = NULL;         ///< pointer to the file
 
    file = fopen("file.txt", "w");  // creates test file in write mode
 
    fprintf(file,
            "hey_this, is a. test input \n to a_file");  // writes test data to
                                                         // test file
 
    closeFile(file);                // closes test file
    file = fopen("file.txt", "r");  // reopens test file in read mode
 
    root = readWordsInFileToTree(file,
                                 root);  // reads words from test file to tree
 
    // Tests to check if words were added to correct position in tree and also
    // if their frequencies were added correctly
    assert(strcmp(root->word, "hey") == 0);
    assert(root->frequency == 1);
    assert(strcmp(root->left->word, "a") == 0);
    assert(root->left->frequency == 2);
    assert(strcmp(root->right->word, "this") == 0);
    assert(strcmp(root->left->right->word, "file") == 0);
    assert(strcmp(root->right->left->word, "is") == 0);
 
    closeFile(file);     // closes test file
    remove("file.txt");  // deletes test file from storage
 
    file = fopen("wordcount.txt", "a");  // creates write file
    fprintf(file, "%-5s \t %9s \t %s \n", "S/N", "FREQUENCY",
            "WORD");  // prints the heading to `wordcount.txt`
    writeContentOfTreeToFile(
        root, file);  // writes content of tree to file (`wordcount.txt`)
 
    // Here is how the output to `wordcount.txt` should look like
    char *correctString =
        "S/N     FREQUENCY   WORD \n"
        "1       2           a \n"
        "2       1           file \n"
        "3       1           hey \n"
        "4       1           input \n"
        "5       1           is \n"
        "6       1           n \n"
        "7       1           test \n"
        "8       1           this \n"
        "9       1           to \n";
 
    int16_t inputChar;  // holds the current character in `wordcount.txt`
    uint64_t i = 0;     // holds the current index in `correctString`
 
    // Checks if the content in `wordcount.txt` is as expected (the same as in
    // `correctString`)
    while ((inputChar = fgetc(file)) != EOF) {
        assert(inputChar == correctString[i++]);
    }
 
    closeFile(file);          // closes `wordcount.txt`
    remove("wordcount.txt");  // deletes `wordcount.txt`
 
    freeTreeMemory(root);  // frees memory taken up by the tree
}

Here is the call graph for this function:

writeContentOfTreeToFile()

void writeContentOfTreeToFile	(	struct Node *	node,
		FILE *	file
	)

Writes contents of tree to another file alphabetically.

Parameters

node	pointer to current node
file	pointer to file

Returns

void

< for word numbering in the write file

{
    static uint64_t i = 1;  ///< for word numbering in the write file
    if (node != NULL)       // checks if the node is valid
    {
        writeContentOfTreeToFile(
            node->left,
            file);  // calls `writeContentOfTreeToFile` for left sub tree
        fprintf(file, "%-5lu \t %-9lu \t %s \n", i++, node->frequency,
                node->word);  // prints the word number, word frequency and word
                              // in tabular format to the file
        writeContentOfTreeToFile(
            node->right,
            file);  // calls `writeContentOfTreeToFile` for right sub tree
    }
}

Here is the call graph for this function: