Hash tables, same record on each hash table cell - c

Question

There is a word dictionary in a text file. I will hash all these words. I wrote some code yet there is a problem. Last word takes place on each hash table records.
main()
{
FILE *fp;
char word[100];
char *hash[569];
int i;
for(i=0;i<569;i++)
hash[i]="NULL";
int m=569;
int z =569;
int mm=568;
char w;
int key;
int j;
int hash1;
int hash2;
fp=fopen("smallDictionary.txt","r");
int counter =0;
while(fscanf(fp,"%s",word)!=EOF)
{
j=0;
counter++;
for(i=key=0;i<strlen(word);i++)
key+=(word[i]-'a')*26*i;
hash1=key%m;
hash2=1+(key%mm);
while(hash[(hash1+j*hash2)%m]!="NULL")
{
j++;
}
hash[(hash1+j*hash2)%m] = word;
}
for(i=0;i<569;i++)
printf("%s ",hash[i]);
fclose(fp);
}
End the result on console.
As it seen, as last word of dictionary, "your" keyword repeats.
Dictionary content :
a about above absolutely acceptable add adjacent after algorithm all
along also an analyses and any anyone are argument as assignment
assume at available be been below bird body but by can cannot
capitalization case center chain chaining changing characters check
checker checkers checking choose class code collision collisions
command compilation compile compiled complexity conform consist
containing contains convenience convert correcting corrections create
created cross deal debugging december decide deducted deleted
departmental dictionary discover discussed divides document
documentation due dynamically e each easiest encountered enough error
errors etc even exactly example executable expand experience factor
fair fall file files find first following font for forth found four
friday from function functions g gain general generate generated
generating geoff get gird given good graders grows guide guidelines
had hair handle has hash hashing have head header help helped hold
homework hour how i if in include including incorrect information
input insert inserted insertions instructions into is ispell it
keeping known kuenning last length less letter letters like line
linear list load long longer longest look looked low lower maintained
many match may messages method midnight might misspelled mistake mode
more most must my name named names necessary need never next no note
number of on once one only options or original other otherwise output
overview page pair pedantic points policies possibility possible
prefer primary probing problem produce produces professor program
purpose quack quadratic quick read reason reasonably refer reference
rehashing reinitialized report resubmit rid same save separate
separated seriously should similar simple simplify single size so
something specifications specified spell spelling standard statistics
string strong submission submit submitted successfully suggest
suggested support suppose table tech th than that the them then there
these this those three through thursday times title to together tooth
track traditionally transposed trial try turing udder under understand
unlike up use used useful using usual variant variants version wall
ward warning was way we when whenever which while whitespace who why
wild will wind wire wiry with word words works write written wrong you
your

Answer 1

hash[(hash1+j*hash2)%m] = word;
That just assigns the address of word to the hash entry. Which is always the same. And at the end of the loop the contents of word is obviously going to be the last thing that was read by fscanf. SO you need something like:
hash[(hash1+j*hash2)%m] = strdup(word);
strdup allocates heap memory so don't forget to free it when the hash table is no longer needed.

Answer 2

All pointers in the hashtable points to the same variable: The word array. Whatever is the last string you put in word, will be the string printed in your output.
You need to allocate memory for each word, either by making hash an array of arrays and copy the word into the secondary array, or using e.g. strdup to allocate the string dynamically.
More graphically, it could be though of as this:
+---------+
| hash[x] | -\ +------+
+---------+ >--- > | word |
| hash[y] | -/ +------+
+---------+ +--------+
| hash[z] | --> | "NULL" |
+---------+ +--------+
Here both the entry x and y points to word, while entry z points to the string literal "NULL" you initialized all entries to.