PLEASE ASAP! ONLY IN C++! PLEASE NEAT WRITTEN AND READ CAREFULLY! I AM HAVING TROUBLE ON THIS! PLEASE HELP! THANK YOU! WILL GIVE THUMB UP IF SATISTIED!

Write a program in C++ language that implements an English Dictionary using Doubly Linked List and OOP concepts. This assignment has five parts: 1- Write a class(new type) to define the Entry type that will hold the word and its definition. 2- Define the Map or Dictionary ADT using the interface in C++. 3- Implement the interface defined on point 2 using Doubly Linked List, which will operate with Entry type. Name this class NodeDictionaryG. Do not forget to create the Node (DNodeG class) for the doubly linked list. 4- Implement the EnglishDictioanry class. 5- Test it in the main function All Constructors should use the initializer list. You must submit in total a minimum of 6 files, min 5 for coding and 1 pdf file with the explanation. 1. Entry class The class should be designed in such a way that can store any type of key and any type of value. In this implementation, we will use it to store . Member variables: K _key;//English word (key) V _value;//word definition (value) Member functions: Entry(K, V); virtual ~ Entry (); K getK (); V getV (); void setK(K); void setV(V); Answer the questions below before implementing class Entry: Which methods should be public and which ones can be private? Should data members be public or private? 2. Define the Map or Dictionary ADT using the interface in C++, the interface should be designed to hold any type. You can find the list of operations in lesson 11 (Map ADT) and lesson 12 (Dictionary ADT) posted on the blackboard. Note: if you define Map ADT you should add the extra operations that Dictionary ADT has during the implementation of the Map interface. 3. Implement the interface defined in point 2 using Doubly Linked List. You can find the C++ header file in lesson 12. You have to make additional implementations as required for new types. NodeDictionaryG class Member variables: int uniqueKeys; //the current number of unique keys in the Dictionary int size // the total number of entries DNodeG* header; // head-of-list sentinel DNodeG* trailer; // tail-of-list sentinel Member functions: NodeDictionaryG (); virtual ~ NodeDictionaryG (); int size() const; // returns the number of nodes int uniqueKeys() const; // returns the current number of unique keys in the Dictionary bool empty() const; // is the list empty IteratorG begin() const; // beginning position IteratorG end() const; // (just beyond) last position IteratorG find(K) const; // returns an iterator that points to the first entry with key k IteratorG put(K, V); // insert pair (k,v) void erase(K& k); // remove the first entry with key k void erase(IteratorG); // erase entry at Iterator void erase(Range); // erase entry at range Range findAll(K); //returns the range for a key void print(Range); //prints all Entries in range Answer the questions below before implementing NodeDictionaryG class: Which methods should be public and which ones should be private? Should data members be public or private? Should we create getters and setters methods for member variables? For which member makes sense to implement them? Implement them. Note: The IteratorG class is defined in lesson 7. The Range type is the type defined in lesson 12. 4. Implement the EnglishDictioanry class using the NodeDictionaryG class operations. The EnglishDictioanry class should have at least the following functions and member variables: EnglishDictionary class Member variables: string name; //will hold the name of the English dictionary NodeDictionaryG dictionary; //will hold the words and their definitions Member functions: EnglishDictionary (string); virtual ~ EnglishDictionary (); int words() const; // number of words in dictionary int uniqueWords() const; // number of unique words in dictionary bool empty() const; // is the dictionary empty void add(Entry) // adds a word with its definition in the dictionary void deleteFirst(string) // removes the first word equal to a given string void delete(string) // removes from dictionary all the words equal to a given string void printDictionary(bool) //prints all words and definitions. If bool is true print from the beginning, else print them from the end of the dictionary (this function should be designed as a recursive function). void printDictionary (string) //prints the definitions for a given word (this function should be designed as a recursive function). Entry find(string) // returns the first word and its definition equal to a given string Answer the questions below before implementing EnglishDictionary class: Which methods should be public and which ones should be private? Should data members be public or private? Should we create getters and setters methods for member variables? For which member makes sense to implement them? Implement them. 5. Test it in the main function Create e English Dictionary with 10 words and their definitions, with word repetition as {3 definitions, 4 definitions, 1 definition, 2 definitions). Print the list of all words and definitions, starting from the beginning. Print the list of all words and definitions, starting from the end. Print the definitions for the word with 2 definitions, starting from the beginning of the range. Print the definitions for the word with 2 definitions, starting from the end of the range. Remove the first definition from the word that has 3 definitions. Search for the word that has 4 definitions and print them all. Remove the first definition from the word that has 4 definitions. Remove all the definitions from the word that has 2 definitions (you have two words that have 2 definitions remove both). Print the list of all words and definitions, starting from the beginning. Print the list of all words and definitions, starting from the end.

My Current Code(Separate Files)

***Implement Only EnglishDictionaryG.cpp***

EnglishDictionaryG.h

#ifndef ENGLISHDICTIONARYG_H_ #define ENGLISHDICTIONARYG_H_

#include #include using namespace std;

class EnglishDictionaryG { private: string name; //will hold the name of the English dictionary EnglishDictionaryG dictionary; //will hold the words and their definitions

public: EnglishDictionaryG(string); virtual ~EnglishDictionaryG(); int words() const; // number of words in dictionary int uniqueWords() const; // number of unique words in dictionary bool empty() const; // is the dictionary empty void add(Entry); // adds a word with its definition in the dictionary void deleteFirst(string); // removes the first word equal to a given string void deleteWord(string); // removes from dictionary all the words equal to a given string void printDictionary(bool) const; //prints all words and definitions. If bool is true print from the beginning, else print them from the end of the dictionary (this function should be designed as a recursive function). void printDictionary (string) const; //prints the definitions for a given word (this function should be designed as a recursive function). Entry find(string) const; // returns the first word and its definition equal to a given string };

#endif /* ENGLISHDICTIONARYG_H_ */

NodeDictionaryG.cpp

#include "NodeDictionaryG.h"

// Constructor template NodeDictionaryG::NodeDictionaryG() : uniqueKeys(0), size(0) { // Initialize the header and trailer sentinels header = new DNodeG(K(), V()); trailer = new DNodeG(K(), V());

// Connect the header and trailer sentinels header->next = trailer; trailer->prev = header; }

// Destructor template NodeDictionaryG::~NodeDictionaryG() { // Clean up the allocated memory for nodes IteratorG it = begin(); IteratorG endIt = end();

while (it != endIt) { IteratorG next = it; ++next; delete it->prev; it = next; }

// Delete the header and trailer sentinels delete header; delete trailer; }

// Getter for size template int NodeDictionaryG::getSize() const { return size; }

// Getter for uniqueKeys template int NodeDictionaryG::getUniqueKeys() const { return uniqueKeys; }

// Check if the dictionary is empty template bool NodeDictionaryG::empty() const { return size == 0; }

// Return an iterator pointing to the beginning of the dictionary template IteratorG NodeDictionaryG::begin() const { return IteratorG(header->next); }

// Return an iterator pointing just beyond the last position of the dictionary template IteratorG NodeDictionaryG::end() const { return IteratorG(trailer); }

// Find the entry with a given key and return an iterator pointing to it template IteratorG NodeDictionaryG::find(K key) const { IteratorG it = begin(); IteratorG endIt = end();

while (it != endIt) { if (it->key == key) { return it; } ++it; }

// Return end() if the key is not found return end(); }

// Insert a new entry into the dictionary template IteratorG NodeDictionaryG::put(K key, V value) { IteratorG it = find(key);

// If the key is already present, update the value if (it != end()) { it->value = value; } else { // Otherwise, add a new entry DNodeG* newNode = new DNodeG(key, value); DNodeG* lastNode = trailer->prev;

// Connect the new node newNode->prev = lastNode; newNode->next = trailer;

// Update the last node and trailer lastNode->next = newNode; trailer->prev = newNode;

// Increment counters ++uniqueKeys; ++size;

// Return an iterator pointing to the new entry return IteratorG(newNode); }

// Return an iterator pointing to the existing entry return it; }

// Remove the entry with the specified key template void NodeDictionaryG::erase(K& key) { IteratorG it = find(key);

// Check if the key is found before attempting to erase if (it != end()) { erase(it); } }

// Erase the entry at the specified iterator template void NodeDictionaryG::erase(IteratorG it) { if (it != end()) { DNodeG* prevNode = it->prev; DNodeG* nextNode = it->next;

// Connect the previous and next nodes prevNode->next = nextNode; nextNode->prev = prevNode;

// Delete the current node delete it.node;

// Decrement counters --size;

// If the key was unique, decrement the uniqueKeys counter if (prevNode == header || nextNode == trailer) { --uniqueKeys; } } }

// Erase the entries within the specified range template void NodeDictionaryG::erase(Range range) { IteratorG it = range.getStart();

while (it != range.getEnd()) { IteratorG next = it; ++next; erase(it); it = next; } }

// Find the range of entries with a given key template Range NodeDictionaryG::findAll(K key) { IteratorG start = find(key); IteratorG end = find(key);

// Increment the end iterator until a different key is encountered while (end != this->end() && end->key == key) { ++end; }

return Range(start, end); }

// Print the entries within the specified range template void NodeDictionaryG::print(Range range) { IteratorG it = range.getStart(); IteratorG endIt = range.getEnd();

while (it != endIt) { cout << "Key: " << it->key << ", Value: " << it->value << endl; ++it; } }

NodeDictionaryG.h

#ifndef NODEDICTIONARYG_H_ #define NODEDICTIONARYG_H_

#include #include #include "DNodeG.h" using namespace std;

template class NodeDictionaryG { private: int uniqueKeys; //the current number of unique keys in the Dictionary int size; // the total number of entries DNodeG* header; // head-of-list sentinel DNodeG* trailer; // tail-of-list sentinel

public: NodeDictionaryG(); virtual ~ NodeDictionaryG (); int getSize() const; // returns the number of nodes int getUniqueKeys() const; // returns the current number of unique keys in the Dictionary bool empty() const; // is the list empty IteratorG begin() const; // beginning position IteratorG end() const; // (just beyond) last position IteratorG find(K) const; // returns an iterator that points to the first entry with key k IteratorG put(K, V); // insert pair (k,v) void erase(K& k); // remove the first entry with key k void erase(IteratorG); // erase entry at Iterator void erase(Range); // erase entry at range Range findAll(K); //returns the range for a key void print(Range); //prints all Entries in range };

#endif /* NODEDICTIONARYG_H_ */