This is an ineffective use of a hash function. In essence, your load function simply inserts each word sequentially into an array, along with a hash number, and the check function is doing a linear search. It might as well be implemented without the hashing, at least it would be a little faster. Bottom line is this is incredibly inefficient.
The purpose of a hash function is to assign a number to each word that can be used to quickly find it by searching a subgroup of the dictionary, not the whole dictionary. Think about it this way. A linear search breaks the dictionary into one single group of 14k elements. It will take a long time to search just one group. Now, if you were to divide the dictionary up into 26 groups based on the first letter, you would only have to search one group. Since the average size of a group is 14k/26 (give or take), the average speed is 26 times faster. Now, if you could divide the dictionary into, say, 1000 different groups, using some hash function, then the average group size would be 14k/1k or 14 words per group. This would run a lot faster because you could then use the hash function to go straight to that group and quickly search those 14 or so words. Even if the group is many times that size, it's still going to be a lot faster than a linear search of the dictionary!
The technique for using a hash function is to create a root array that serves as the starting point of all the buckets. Each bucket is a linked list. The hash value for a word tells which bucket to use. In other words, the hash value returned is the array index to use. For example, a word has a hash value of 538. The word should be added to the linked list that starts at array. The hash value does not need to be stored in the node. Since the idea is to keep the length of the linked list to a minimum, having a sorted list will have little impact on the performance of check, but sorting of the list will impact load, probably more than it benefits. So, it only remains to decide how to add a node to the list. In practice, it is more efficient to add it to the beginning of the list than anywhere else. I'll let you contemplate why. ;-)
A couple of other issues I saw. First, your hash function is not bounded. It can produce very large hash numbers. If you wish to implement the concepts I've described, you will need to limit the size of the hash so that the number produced is within the bounds of the dictionary table range. This would be easily done with a modulo operation.
return h % HASH_MAP_BIN_SIZE;
This guarantees that the hash number is in the desired range.
Next, you have
HASH_MAP_BIN_SIZE defined, but then have used 143091 in the code. You should use HASH_MAP_BIN_SIZE and not hard code the number in the code. This has the added benefit of playing with the size of the hash by changing the value in one place at the top of the file to see what impact it has on performance.
As for hashing to exactly 143091, the number of words in the dictionary, you'll find it difficult to get a perfect hash. (google "perfect hash" and you can get a fuller explanation.) Simply put, once the hash range gets to a certain point, diminishing returns sets in - increasing the range uses up more and more resources while producing less and less benefit in speed. I'll leave it to you to play with the number of bins to see the effect.
That's a pretty long overview of what's happening in your code. Hope it helps.
If this answers your question, please click on the check mark to accept. Let's keep up on forum maintenance. ;-)