For this problem, let us take the linked list we wrote in a functional manner in a previous assignment and convert it into a Linked List class. For extra practice with pointers well expand its functionality and make it a doubly linked list with the ability to traverse in both directions. Since the list is doubly linked, each node will have the following structure: struct Node { int number; Node * nextNode; Node * prevNode; }; In addition, well maintain both a head node and a tail node as variables within the class. Your class, therefore, should have at least two private attributes (data members): (a) a Node variable that serves as the head node; (b) a Node variable that serves as the tail node. (This list can be expanded later as we add functionality to the class.) Description of the class At the minimum, your class should have the following public member functions: 1. A default constructor. This constructor will: a. Initialize the head node and the tail node. b. Set the previous node pointer of the head node to nullptr and the nextNode pointer to point to the tail node. c. Set the previous node pointer of the tail node to point to the head node and the next node pointer to nullptr. 2. Node * addNodeToEnd (int value); This function will add a node to the end of the list, set the nodes value, and return a pointer to the new node added. 3. Node * addNodeToBeginning (int value); This function will add a node to the beginning of the list, set the nodes value, and return a pointer to the new node added. 4. void printListForward (); This member function will traverse the list from the first node to the last node and print out the values using the formatting requirements weve maintained throughout the semester (e.g., 10 numbers per line, 5 byte field, etc). 5. void printListBackward (); This member function will traverse the list from the last node to the first node and print out the values using the formatting requirements weve maintained throughout the semester (e.g., 10 numbers per line, etc). 6. void sort (); This member function will sort the numbers in the list by using one of the sorting algorithms weve implemented before. (I suggest using Bubble Sort, as it works with adjacent elements.) Note that it is not necessary to swap actual Nodes; the sort can be performed by simply swapping values between nodes. 7. int & operator [ ] (const int &); Implement the overloaded subscript operator on your list. This operator should return a reference to the data value of the specified node. For example, list[5] would return a reference to the data item of the sixth element in the list. Demonstrate the use of your operator by taking an element, say the 5th, changing its value, and then reprinting the list to show that the value was indeed changed. (e.g., list[5] = 100;) You should have some code that displays an error message if the index supplied is out of bounds. 8. A destructor for the list. This member function will traverse the list and delete each node in turn. General Tasking Once the LinkedList class is built, have your main() function perform the following tasks: 1. Instantiate a LinkedList object. 2. Read the data from the same file we used in the previous linked list problem, Perm 50.txt, into the list. 3. Print the list in forward order by using the printListForward() member function. 4. Sort the list by calling the sort() member function. 5. Print the list in forward order again, but after it has been sorted. 6. Print the list in reverse order using the printListBackward() member function. 7. Demonstrate the use of the overloaded subscript operator by using it to change a value in the list, then reprinting the list the list in the forward direction one last time. Make all reports neat and professional in appearance. Some Comments: This is a very basic doubly linked list data structure; much more functionality can be added to a list like this. To name just a few items, we could also have: 1. the ability to add nodes to the list at arbitrary locations within the list. 2. the ability to remove nodes at arbitrary locations from the list. 3. a counter that counts the number of elements in the list. 4. an iterator that can traverse the list. All of this functionality and more is typical of linked list data structures and would make our list more robust and useful. Nevertheless, it should be clear that once the list is built, it is far easier to use and maintain as a class than as a series of functions that are disassociated from the data they are working on.