CS50 speller: Unload executes 80,000,000+ frees - c

Question

This is pset 5 in Harvard's CS50. It consists mainly of loading the dictionary, checking whether each word in the chosen text is found within the loaded dictionary and then unloading (freeing all of the allocated memory).
All the other functions work but when it comes to unload it just executes, as stated, 80,000,000+ frees, whilst in the program there is just 143,094 mallocs, I am a newbie so this is mindblowing for me. Below are the relevant functions for unload.
Edit (1): Here is some context regarding the variable hashtable.
typedef struct node
{
char word[LENGTH+2];
struct node *next;
}
node;
node *hashtable[264636] = { NULL };
I initialize each element to NULL so that in unload I can easily skip the index values for which no key was generated in the hash function.
//LOAD FUNCTION: Loads the dictionary into a hash table. Djb2 function used.
bool load(const char *dictionary)
{
head = malloc(sizeof(node));
head->next = NULL;
if (head == NULL)
{
unload();
return false;
}
opntr = fopen(dictionary, "r");
while (fscanf(opntr, "%s", WORD) != EOF)
{
wnode = malloc(sizeof(node));
if (wnode == NULL)
{
unload();
return false;
}
strcpy(wnode->word, WORD);
wnode->next = head;
head = wnode;
unsigned long key = hash(wnode->word);
hashtable[key] = wnode;
wnode = wnode->next;
}
return true;
}
// Checks whether the input word is somewhere within the dictionary
bool check(const char *word)
{
char dword[strlen(word) + 1];
strcpy(dword, word);
for (int c = 0; c < strlen(dword); c++)
{
dword[c] = tolower(dword[c]);
}
int key_w;
key_w = hash(dword);
node *cursor = hashtable[key_w];
while (cursor != NULL)
{
if (strcmp(cursor->word, dword) == 0)
{
return true;
}
cursor = cursor->next;
}
return false;
}
// Unloads memory allocated (?) to store the dictionary
bool unload(void)
{
for (int in = 0; in < 264636; in++)
{
node *fhead = hashtable[in];
while (fhead != NULL)
{
node *fcursor = fhead->next;
free(fhead);
fhead = fcursor;
}
}
return true;
}

Answer 1

In case anybody finds it helpful, the problem was within the load function. The nodes malloced were updated wrongfully so that the elements of the hashtable array weren't independent linked lists and I was unnecessarily using a head node to point to the first element of the list each time we wanted to add a node. Instead, to add a new node to its corresponding element in the hashtable array, we use the element itself as the head of the linked list and we arrange it so that it points to each node added, thus succesfully keeping track of the beginning of the linked list. Each element in the hashtable is initially pointing to NULL so that we can find the end of each linked list.
int null()
{
for (int i = 0; i < 264636; i++)
{
hashtable[i]->next = NULL;
}
return 0;
}
bool load(const char *dictionary)
{
opntr = fopen(dictionary, "r");
while (fscanf(opntr, "%s", WORD) != EOF)
{
wnode = malloc(sizeof(node));
if (wnode == NULL)
{
unload();
return false;
}
strcpy(wnode->word, WORD);
unsigned long key = hash(wnode->word);
wnode->next = hashtable[key];
hashtable[key] = wnode;
}
return true;
}