Dictionary not loading and spell checking words correctly - c

Question

I am working on a pset, where we have to implement load, hash, size, check and unload functions as efficiently as possible using a hash table in such a way that TIME IN load, TIME IN check, TIME IN size, and TIME IN unload are all minimized.
When I test it with a given text, I am having the following message:
WORDS MISSPELLED: 17187
WORDS IN DICTIONARY: 1
WORDS IN TEXT: 17756
TIME IN load: 0.00
TIME IN check: 0.01
TIME IN size: 0.00
TIME IN unload: 0.00
TIME IN TOTAL: 0.01
The dictionary is not working correctly as I did not implement hash and check as per conditions but I do not know how. Check must be case insensitive and will only be passed words that contain (uppercase or lowercase) alphabetical characters and possibly apostrophes.
Can you help me on this and point any other potential errors I made.
// Represents a node in a hash table
typedef struct node
{
char word[LENGTH + 1];
struct node *next;
}
node;
// Number of buckets in hash table
const unsigned int N = 17576; // for the first 3 letters so 26*26*26
// Hash table
node *table[N];
unsigned int hash_value; // initialise positive int value
unsigned int word_counter; // initialise positive int word counter
// Returns true if word is in dictionary, else false
bool check(const char *word)
{
// TODO
//Hash the word to obtain the hash value;
hash_value = hash(word);
//Access linked list at the given index in the hash table, we are creating a trav pointer to the head of list indexed via the hash function
for (node *cursor = table[hash_value]; cursor!= NULL; cursor = cursor->next)
{
if (strcasecmp(word, cursor->word) == 0)
{
return true;
}
}
return false;
}
// Hashes word to a number
// hash function was taken from : stackexchange.com
unsigned int hash(const char *word)
{
for (hash_value = 0; *word != '\0'; word++)
{
hash_value = *word + 31 * hash_value;
}
return hash_value % N;
}
// Loads dictionary into memory, returning true if successful, else false
bool load(const char *dictionary)
{
// TODO
//allocate memory for all node buckets
for (int i = 0; i < N; i++)
{
table[i] = NULL;
}
//Open dictionary
FILE *file = fopen(dictionary, "r");
if (file == NULL) // check if file is not empty)
{
printf("Error, empty file\n");
return 1;
}
char word[LENGTH + 1];
while (fscanf(file, "%s", word) != EOF)
{
//create a new node
node *new_node = malloc(sizeof(node));
if (new_node == NULL) // check if enough memory
{
return false;
}
else
{
strcpy(new_node->word, word); //copies word into new_node->word;
hash_value= hash(word);
//Insert the node into the hash table
new_node->next = table[hash_value];
/set the head to the new pointer, so it is inserted in front
table[hash_value] = new_node;
word_counter ++;
}
fclose(file);
}
return true;
}
// Returns number of words in dictionary if loaded, else 0 if not yet loaded
unsigned int size(void)
{
// TODO
if (word_counter > 0)
{
return word_counter;
}
else
{
return 0;
}
}
// Unloads dictionary from memory, returning true if successful, else false
bool unload(void)
{
// loop through all buckets ( ie all indexes of the array of linked lists)
for (int i = 0; i < N; i++)
{
node *cursor = table[i]; // place cursor to each bucket
while (cursor!= NULL) //
{
node *tmp = cursor->next; // create a tmp equal to cursor
free(cursor);
cursor = tmp;
}
return true;
}
return false;
}