implement dictionary with hashtable c++

[93MGz8AR]

I want to implement a dictionary using a hashtable. I have a "word" textfile that contains a list of over 100,000 words (each word is separated by a newline and the words are only composed of letters and apostrophes) that I'll have to load into memory, and another file that I'll have to spell check against the dictionary (this file can be composed of anything, so I'll only spell check the words that are composed of letters and apostrophes.

#include <iostream>
#include <fstream>
#include <cctype>
#include <cstring>
#include <sys/resource.h>

int size = 0;

const int sizeofarray = 5000;

using namespace std;

double calculate(const rusage *b, const rusage *a);

int check();

struct node
{
	char word[50];
	node * nextnode;
};

node* dict[sizeofarray];

int hash(node*);

void unload(node*);

int main()
{
	rusage before, after;
	char temp[50];
	char tempchar;
	int a;
	int b;
	
	ifstream dictionary("~/Desktop/words");
	
	for(int s=0; s<sizeofarray; s++)
		dict[s]=NULL;
	
	getrusage(RUSAGE_SELF, &before);
	
	while(!dictionary.eof())
	{	
		a=0;
		while(1)
		{
			dictionary.get(tempchar);
			tempchar = tolower(tempchar);
			if(tempchar!='\n')
			{
				temp[a]=tempchar;
				a++;
			}
			else
			{
				temp[a]='\0';
				size++;
				node* tempnode = new node;
				tempnode->nextnode==NULL;
				strcpy(tempnode->word, temp);
				b=hash(tempnode);
				if(dict[b]==NULL)
					dict[b]=tempnode;
				else
				{
					tempnode->nextnode=dict[b];
					dict[b]=tempnode;
				}
				break;
			}
		}
	}
	getrusage(RUSAGE_SELF, &after);
	
	cout << "\nLoading words into dictionary: " << calculate(&before, &after) << endl;
	
	cout << "\nSize of dictionary: " << size << " words.\n";
	
	getrusage(RUSAGE_SELF, &before);
	
	check();
	
	getrusage(RUSAGE_SELF, &after);
	
	cout << "\nChecking file against dictionary: " << calculate(&before, &after) << endl;
	
	getrusage(RUSAGE_SELF, &before);
	
	for(int sh=0; sh < sizeofarray ;sh++)
	{
		unload(dict[sh]);
		dict[sh]=NULL;
	}
	
	getrusage(RUSAGE_SELF, &after);
	
	cout << "\nUnloading dictionary: " << calculate(&before, &after) << endl;
	
	return 0;
}

int check()
{
	ifstream spellcheck("/Users/bandi/Downloads/pset6/texts/pneumonoultramicroscopicsilicovolcanoconiosis.txt");
	if(spellcheck.fail())
	{
		cout << endl << "spellcheck fail" << endl;
		return -1;
	}
	int a;
	char tempword[50];
	char temp='a';
	int misspellings = 0;
	int noofwords = 0;
	node * comparetemp = NULL;
	while(!spellcheck.eof())	
	{
		a=0;
		while(1)
		{
			spellcheck.get(temp);
			temp = tolower(temp);
			if(isalpha(temp) || temp=='\'')
			{			
				tempword[a] = temp;	
				a++;
			}
			else if(isspace(temp) || spellcheck.eof())
			{
				tempword[a] = '\0';
				noofwords++;
				node * tempwordcheckhash = new node;
				strcpy(tempwordcheckhash->word, tempword);
				comparetemp = dict[hash(tempwordcheckhash)];
				while(1)
				{
					if(comparetemp!=NULL)
					{
						if(!(strcmp(comparetemp->word, tempwordcheckhash->word)) && comparetemp->nextnode==NULL)
						{
							cout << endl << tempwordcheckhash->word;
							misspellings++;
							break;
						}
						else if(strcmp(comparetemp->word, tempwordcheckhash->word))
							break;
						comparetemp = comparetemp -> nextnode;
					}
					else
					{
						cout << endl << tempwordcheckhash->word;
						misspellings++;
						break;
					}
				}
				
				delete tempwordcheckhash;
				tempwordcheckhash = NULL;
				
				while(!spellcheck.eof() && (!isalpha(temp) || temp=='\''))
					spellcheck.get(temp);
				
				spellcheck.seekg(-1, ios::cur);
				
				break;				
			}
			else
			{
				while(!spellcheck.eof() && (!isalpha(temp) || temp=='\''))
					spellcheck.get(temp);
				
				spellcheck.seekg(-1, ios::cur);
				break;
			}
		}
	}
	cout << endl << "Total misspellings: \t" << misspellings << endl;
	cout << endl << "Total words: \t" << noofwords << endl;
	return 1;
}

void unload(node * foo)
{
	if(foo == NULL || foo->nextnode == NULL)
		delete foo;
	else
		unload(foo->nextnode);
	
}

int hash(node* aNode)
{
	int h=0;
	int hashno=0;
	while(aNode->word[h] != '\0')
	{
		hashno = hashno + 50*tolower(aNode->word[h]) - tolower(aNode->word[h]);
		h++;
	}
	hashno=hashno % sizeofarray;
	return hashno;
}

double
calculate(const struct rusage *b, const struct rusage *a)
{
    if (b == NULL || a == NULL)
        return 0;
    else
        return ((((a->ru_utime.tv_sec * 1000000 + a->ru_utime.tv_usec) -
				  (b->ru_utime.tv_sec * 1000000 + b->ru_utime.tv_usec)) +
				 ((a->ru_stime.tv_sec * 1000000 + a->ru_stime.tv_usec) -
				  (b->ru_stime.tv_sec * 1000000 + b->ru_stime.tv_usec)))
                / 1000000.);
}

I seem to be having some bugs.

[Seraphimsan]

and they would be?