22C:21 Project 1 Solution

Version 1. This is a partial implementation of the wordList class. The main purpose of this version is to implement and test hashing with quadratic probing. Some of the methods (e.g., the print methods) are just "stubs" to be filled in later and some of the other functions don't have full functionality yet (e.g., insert does not do resizing). I tested both the correctness and the performance of this implementation, using a program called wordListTester.java. This program simply inserts the 5-letter words from words.dat into a wordList object and then searches for some words we would expect to be in the word list and some that we expect to be missing from the word list. The output from this program is in wordListTester.out.5. I used a table that would be 5 times as large as the number of words the user expects to store in the table. With this load factor the insert function makes about 0.187 probes per word inserted, which is excellent! I also tried changing the wordList class to make a table twice as large as the number of words the user expects to store in the table. With this load factor, the average number of probes per word inserted should go up and and it does increase to 1.108. See wordListTester.out.2 for the output from this run.
Version 2. This is a partial implementation of the wordList class and the buildDict class. The main purpose of this version was to parse text files, construct words, and then insert them into a dictionary implemented as a wordList object. The wordList class is still incomplete in two ways: (i) I have not written a function for returning an appropriate prime and (ii) the insert method does not do resizing of the hash table. To test the implementation of both wordList and buildDict, I contatenated the three novels, alice.txt, hyde.txt, and carol.txt into one file, called novels.txt and ran buildDict on this file. I ran buildDict twice, once in a "verbose" mode that gives me useful information for error checking and once a "regular" mode. The respective outputs are here: novels.out.verbose and novels.out. These two output files contain all sorts of useful information. For example, after inserting all the words into the dictionary I see from novels.out that:
```
	The size of the hash table is 35000
	The number of words in the hash table is 7883
	The number of probes per insertion table is 0.5534694913104148
	The maximum number of probes over all insertions is 10.0
```
From novels.out.verbose I see that the word "the", when encountered the first time produces the output:
```
	word being inserted: the
	slot index: 22233
	Inserted word.
```
Every subsequent ocurrence of "the" (and there are many such ocurrences, as you can expected) produces the output:
```
	word being inserted: the
	slot index: 22233
	Word already in table.
```
Another output fragment that helps us understand that things are working fine is
```
	word being inserted: Us
	slot index: 2039
	slot index: 2040
	slot index: 2043
	slot index: 2048
	Inserted word.
```
This shows that quadratic probing is in action; the first probe is at 2039, the next probe is 1 slot away, the next is 4 slots ways, the next is 9 slots away, etc.
Version 3. This is a partial implementation of the wordList class, the buildDict class, and the the spellCheck class. While the implementation is partial because it is missing some of the functionality asked for in the project handout, it provides most of the functionality. Specifically, here is the functionality that is missing:
- The wordList class is just missing the implementation of one required method: the one that prints into a file all the words in the wordList object.
- The buildDict class does not read from multiple text files; it expects all its input to come from one file.
- The spellCheck class has the most deficiencies. It interacts with the user in a limited way and does not provide the "replace all" or the "ignore all" options.
The small amount of testing I did (thus far) is in files:
- input2.txt, output2.txt, interaction2.txt.