UNIVERSITY OF MASSACHUSETTS LOWELL Department of Electrical and Computer Engineering. Program 10 EECE.3220 Data Structures Fall 2017.

Transcription

1 UNIVERSITY OF MASSACHUSETTS LOWELL Department of Electrical and Computer Engineering Program 10 EECE.3220 Data Structures Fall 2017 Hash Tables Program 10 is a repeat of Program 9, but in Program 10 the word list will be stored as a hash table. This program uses 3 of the data structures from class: hash tables, binary search trees, and linked lists. Program 10 supports the following commands: Command A C D I O Q Description Remove entries one at-a-time from the hash table, inserting each word into a binary search tree until the hash table is empty; then display the BST in alphabetical order. After displaying the alphabetized list, remove leaf nodes from the BST one at-a-time, inserting them back into the hash table until the BST is empty. Clear (erase) the entire hash table. Accept a word from the keyboard and delete it from the hash table. Accept a word from the keyboard and if not already there insert it into the hash table. If the word is already in the table simply update its count. Ask for the name of a text file from the keyboard. Open and read the text file, storing words and their number of occurrences in the hash table. The word list is stored as a hash table, sorted only when needed into a binary search tree. After using the sorted list, it must be restored to a hash table. Terminate the application. Hash Table Collision Handling The words of the dictionary are to be stored in a hash table. Collisions are to be handled by chaining. The hash table is an array of pointers to linked lists (buckets). Each bucket stores words that hash to one position in the hash table. Your Program 4 linked list class will be used to operate on the bucket lists. Hash Function Use the first and last letters in the word to form x in the following equation to randomize the distribution of your hash function: Hash(x) = ((C1 * x) + C2) % C3 % Capacity where x = word[0]+(word[word.size()-1]<<8) where C1 = 25173, C2 = 13849, C3 = 65536, and Capacity = 11. Note that you need not provide a destructor function, a copy constructor, or assignment operator for your hash table class. BST Module Use your BST class template from Program 8. You will need to add the two functions RemoveLeaf() and RRemoveLeaf() given below, and remove the function OutputByLevel(). Linked List Module Use your linked list class from Program 4 to implement the chained buckets; convert this class to a class template.

2 Program 10 EECE.3220 Page 2 REQUIRED FILES The following files are required. FILES Prog10.cpp Provided do not modify. HashTable_T.h You supply this module. BST_T.h Your Program 8 file BST_T.h updated LinkedList_T.h Your program 6 linked list module CONTENTS The main program file. Defines the class template for class HashTable. Same as Program 8, but remove the function OutputBylevel(), add the public member function RemoveLeaf() and the private member function RRemoveLeaf(). Same as Program 6, but convert your linked list class to a class template. In addition to turning the class into a class template you must also add one inline member function called Update( ) whose purpose is to update the data member of a linked list node.. Here is the function definition to add to your linked list class definition: WordCounter.h CursorCntl.h CursorCntl.cpp Provided, do not change. Provided, do not change // Update the current entry. void Update(const NodeData &d) assert(!atend()); current->data = d; } Defines a class WordCount, whose objects store a word string along with an unsigned integer that counters the number of occurrences of that word. This version adds the function HashKey( ). The CursorCntl module provides functions for controlling the cursor position in the console window. >i tom >i bob >i sue >i ralph >i tom >i bob >i sue >i tom >i bob >i tom >a bob=3 ralph=1 sue=2 tom=4 >d bob >a ralph=1 sue=2 tom=4 SAMPLE RUN >c >owordfile.txt >d all >d come >d jumped >d fox >a brown=3 doggie=9 for=5 good=7 is=2 lazy=8 men=8 now=1 over=6 party=13 quick=2 the=23 time=4 to=20 >q Press any key to continue.

3 Program 10 EECE.3220 Page 3 Hash Table Module The class definition for the HashTable class template is shown below: REQUIRED HASH TABLE CLASS TEMPLATE DEFINITION #include "LinkedList_T.h" //----- c l a s s H a s h T a b l e template <typename ItemData, unsigned NumBuckets> class HashTable public: //Constructor: Make all buckets empty. HashTable(); // Search the table for entry "d." If "d" is found, return true,make "d" // the current entry for this bucket, and make this the current bucket. // If "d" is not found, return false. bool Search(ItemData &d); // Add an entry to the table. void Insert(ItemData &d); // Delete the current entry. void Delete(); // Return true if the table is empty. bool Empty() return size == 0; } // Return the number of entries in the table. unsigned Size() return size; } // Return the current entry. ItemData CurrentEntry(); // Remove the first entry from the table. ItemData Remove(); // Output the entire table to the stream "os", 1 entry per line. void Output(ostream &os); // Show the hash table on the right side of the screen. void Show(); unsigned size; // The number of entries in the table. unsigned curbucket; // The index of the current bucket LinkedList<ItemData> *bucket[numbuckets]; // Array of pointers to linked lists // The hashing function unsigned long Hash(unsigned x); BST Module This is the BST class template from Program 8 with the following changes: 1. Do not include Queue_T.h. 2. Remove the function OutputByLevel( ). 3. Add the public function RemoveLeaf() see below. 4. Add the private function RRemoveLeaf( ) see below. The class definition for the BST class template is shown below:

4 Program 10 EECE.3220 Page 4 REQUIRED BST CLASS TEMPLATE DEFINITION template <typename NodeData> class BST // Tree node class definition struct Node // Constructors Node() : left(0), right(0) } Node(const NodeData &d) : data(d), left(0), right(0) } // Data Members NodeData data; // The "contents" of the node Node *left; // Link to the left successor node Node *right; // Link to the right successor node public: // Constructor BST() : root(0), current(0) } // True if the tree is empty bool Empty() const return root == 0;} // Search for an entry in the tree. If the entry is found, // make it the "current" entry. If not, make the current entry // NULL. Return true if the entry is found; otherwise return false. bool Search(NodeData &d); // Add a new node to the tree. void Insert(NodeData &d); // Delete the current node. void Delete(); // Remove the leftmost leave node and return its data. NodeData RemoveLeaf() return RRemoveLeaf(root); } // Output the tree to the "os" in the indicated sequence. void OutputInOrder(ostream &os) const; // Output inorder void OutputPreOrder(ostream &os) const; // Output preorder void OutputPostOrder(ostream &os) const; // Output postorder // Retrieve the data part of the current node. NodeData &Current() assert(!empty()); return current->data; } // Show the binary tree on the screen. void ShowTree() const; Node *root; // Points to the root node Node *current; // Points to the current node Node *parent; // Points to current node's parent // Recursive Search bool RSearch(Node *subtree, NodeData &d); // Recursive remove the leftmost leave node and return its data. NodeData RRemoveLeaf(Node *&r); // Recursive Insert void RInsert(Node *&subtree, NodeData &d); // Recursive Traversal Functions void ROutputInOrder(Node *subtree, ostream &os) const; void ROutputPreOrder(Node *subtree, ostream &os) const; void ROutputPostOrder(Node *subtree, ostream &os) const; // Find the parent of leftmost right successor of the current node. Node *ParentOfLeftMostRightSucc(Node *node, Node *parent) const; // Show the binary tree on the screen. void RShowTree(Node *subtree, int x, int y) const;

5 Program 10 EECE.3220 Page 5 Function RRemoveLeaf() /* R R e m o v e L e a f ( ) PURPOSE Remove the leftmost leaf node and delete it from the tree. PRECONDITION the subtree "r" is not empty. INPUT PARAMETERS r - the root node of the subtree from which the leaf node is to be removed RETURN VALUE the data part of the removed leaf node */ template <typename NodeData> NodeData BST<NodeData>::RRemoveLeaf(Node *&r) // Make sure that the tree is not empty. assert(r!= 0); // Does this node have any successors? if (r->left!= 0) // There is a left successor, traverse left subtree return RRemoveLeaf(r->left); else if (r->right!= 0) // There is a right successor, traverse right subtree return RRemoveLeaf(r->right); else // There are no successors; it's a leaf node, capture node data NodeData result = r->data; // Delete the leaf node delete r; // Mark the subtree empty r = 0; } // Return the data from the removed node. return result; }

6 Program 10 EECE.3220 Page 6 Word Counter Module The class definition for the HashTable class template is shown below: REQUIRED WORD COUNTER CLASS DEFINITION (Updated) class WordCount public: // Constructors WordCount() : word(""), count(0) } WordCount(string theword, unsigned thecount = 1) : word(theword), count(thecount) } // Accessors string Word() const return word; } unsigned Count() const return count; } unsigned Size() return word.size(); } // Hash key unsigned HashKey() return word[0] + (word[word.size()-1]<<8); } // Mutator void Update() ++count; } // Output a Word to a stream. void Show(ostream &os) os << word << "=" << count; } // Overloaded operators bool operator<(wordcount &rhs) return word < rhs.word; } bool operator<=(wordcount &rhs) return word <= rhs.word; } bool operator>(wordcount &rhs) return word > rhs.word; } bool operator>=(wordcount &rhs) return word >= rhs.word; } bool operator==(wordcount &rhs) return word == rhs.word; } bool operator!=(wordcount &rhs) return word!= rhs.word; } string word; // The word to be counted unsigned count; // The number of occurrences

7 Program 10 EECE.3220 Page 7 Linked List The class definition for the LinkedList class template is shown below (same as Program 4): REQUIRED LINKED LIST CLASS TEMPLATE DEFINITION (Updated) //----- C l a s s L i n k e d L i s t template <typename NodeData> class LinkedList // List node class definition struct Node NodeData data; // The "contents" of the node Node *next; // Link to the next node // Node Constructor Functions Node()} Node(const NodeData &thedata, Node * const thenext = 0) : data(thedata), next(thenext) } public: // Constructors LinkedList(); // True if the list is empty bool Empty() const; // True if the current position is beyond the last entry. bool AtEnd() const; // Rewind the current entry to the beginning of the list. void Rewind() current = first; pred = 0; } // Skip to the next entry in the list. void Skip(); // Get the contents of the current list entry. NodeData CurrentEntry(); // Insert a new list entry before the current entry. void Insert(const NodeData &d); void Increment() assert(!atend(); current->update); } // Update the current entry. void Update(const NodeData &d) assert(!atend()); current->data = d; } //Delete the current entry. //The new current entry is the successor of the deleted node. void Delete(); Node *first; Node *current; Node *pred; // Points to the first node in the list // Points to the current node // Points to the node preceding the current entry.

8 Program 10 EECE.3220 Page 8 GENERAL REQUIREMENTS 1. Your hash table must be implemented as class template in the file HashTable_T.h, and must be completely generic, having no knowledge of the structure of the data part of an entry. 2. Use the provided files Prog10.cpp, WordCount.h, CursorCntl.cpp and CursorCntl.h starter files without change. 3. You may not define any additional data members. 4. Use your BST class template from Program 8 updated as described above.. 5. Use your linked list class from Program 4converted to a class template. 6. Your program's output must appear exactly as shown in the sample run above, producing exactly the same output format. 7. Use const definitions to define symbolic constants rather than hard-coding constants into your program. For example specify the array dimensions (size) with a symbolic constant. Then, it is easy to change the sizes of all of the arrays. Do not use #define to name constants. 8. Use descriptive names throughout your program. Strive to make your code so readable that is self-explanatory. 9. Use a consistent indentation scheme to help show the structure of your program. 10. Use a consistent capitalization convention to distinguish variables from constants. The preferred convention is that constant names, type names, class names, and function names have the first letter of each word capitalized (e.g., MaxCurvePoints). Variable names, data members, and parameter names, have the first letter of every word except the first capitalized (e.g., thepoint, numpoints). Using this convention, names representing values that may change (L-values) start with lower case. If a name starts with a capital, its value cannot be changed. 11. Include a sufficient number of comments to explain your program. See your instructor s demo programs, which illustrate acceptable comment usage. 12. Do not use goto statements. 13. Do not use global variables. 14. No function definition may be longer than one page (60 lines). 15. Do not use redundant code. If you need the same procedure in more than one place, make it a function. 16. Keep your functions simple. If your program seems overly complex, it probably is. This means that you did not spend enough time designing, before you started typing code. KEEP IT SIMPLE! 17. Eliminate all warning messages. 18. Do not use C-style input-output functions (stdio) such as printf(), scanf(), getchar(), putchar(), etc. Hand in the following items: SUBMISSION REQUIREMENTS 1. A computer printout of the files HashTable_T.h, LinkedList_T.h, and BST_T.h. 2. A computer printout of 2 test run(s) of your program showing two examples of your program s operation. Make sure that you include the sample run shown above. 3. Zip up the source files: HashTable_T.h, LinkedList_T.h and BST_T.h. Name the zip file LASTNAME.zip, and submit it via blackboard. These source files must be identical to the printouts from item 1. If you make changes, then submit the changed version. Only the last submission will be graded. Make sure that your zip file includes only the requested files and no folders. NOTE: Programs received after 1:00 PM on the due date will be considered late.