Question

Program 2: Linked List Class 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 we'll 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, we'll 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.) These can be instantiated as actual objects within your list, and do not need to be dynamically allocated. A conceptual diagram of such a list might look like this: -1 13 25 -1 The node containing -1 on the left is the head node, while the node containing -1 on the right is the tail node. These two nodes are not really part of the list; they merely anchor it at both ends. The actual list in this case consists of just two elements, 13, and 25, with 13 being the first element and 25 being the last element in the actual list. Note that if we add a node to the beginning of the list, we merely add it immediately after the head node, changing all relevant pointers of course. Similarly, if we want to add a node to the end of the list, we add the node immediately before the tail node, while, again, changing all relevant pointers. In this way, the head and tail nodes always remain the anchors at both ends of the list.
I need this in C++. This is all one question

Answer 1

// C++ program to create and implement LinkedList class

#include <iostream>
#include <fstream>
using namespace std;

// structure to represent Node of the LinkedList
struct Node {
   int number;
   Node * nextNode;
   Node * prevNode;
};

class LinkedList
{
private:
   Node *head;
   Node *tail;
public:
   LinkedList();
   Node * addNodeToEnd (int value);
   Node * addNodeToBeginning (int value);
   void printListForward ();
   void printListBackward ();
   void sort ();
   int & operator [ ] (const int &);
   ~LinkedList();
};

// default constructor to create an empty list
LinkedList::LinkedList()
{
   // create new node for head and tail
   head = new Node;
   tail = new Node;
   head->prevNode= nullptr; // set prev of head to null
   head->nextNode = tail; // set next of head to tail
   tail->prevNode = head; // set prev if tail to head
   tail->nextNode = nullptr; // ste next of tail to null
}

// function to add a node to the beginning of the linked list
Node* LinkedList::addNodeToBeginning(int value)
{
   // create a new node with value
   Node *node = new Node;
   node->number = value;
   node->prevNode= head;
   // set next of node to node which was previous next of head
   node->nextNode = head->nextNode;
   head->nextNode->prevNode = node; // set prev of node next to head to node
   head->nextNode = node; // update next of head to node

   return node;
}

// function to add a node at the end of the linked list
Node * LinkedList::addNodeToEnd(int value)
{
   if(head->nextNode == tail) // if empty list, call addNodeToBeginning function
   {
       return addNodeToBeginning(value);
   }else
   {
       // create a new node with value
        Node *node = new Node;
       node->number = value;
       // set prev of node to prev of tail
       node->prevNode = tail->prevNode;
       // set next of node prev to tail to node
       tail->prevNode->nextNode = node;
       // set next of node to tail
       node->nextNode = tail;
       // set prev of tail to node
       tail->prevNode = node;
       return node;
   }
}

// function to display the list in forward direction
void LinkedList::printListForward()
{
   if(head->nextNode == tail) // empty list
   {
       cout<<"Empty list"<<endl;
   }else
   {
       Node *curr = head->nextNode; // set curr to first node
       int count = 0;
       // loop over the list to display 10 elements in a line
       while(curr != tail)
       {
           count++;
           cout<<curr->number<<" ";
           if((count == 10) && (curr->nextNode != tail))
               cout<<"\n";
           curr = curr->nextNode;
       }

       cout<<endl;
   }
}

// function to display the list in backward direction
void LinkedList::printListBackward()
{
   if(head->nextNode == tail) // empty list
   {
           cout<<"Empty list"<<endl;
   }else
   {
       Node *curr = tail->prevNode; // set curr to last node
       int count = 0;
       // loop over the list to display 10 elements in a line
       while(curr != head)
       {
           count++;
           cout<<curr->number<<" ";
           if((count == 10) && (curr->prevNode != head))
               cout<<"\n";
           curr = curr->prevNode;
       }

           cout<<endl;
   }

}

// function to sort the list in ascending order using bubble sort
void LinkedList::sort()
{
   if(head->nextNode != tail)
   {
       Node *curr;
       bool swapped = true;
       while(swapped)
       {
           curr = head->nextNode;
           swapped = false;

           while(curr->nextNode != tail)
           {
               if(curr->number > curr->nextNode->number)
               {
                   int value = curr->number;
                   curr->number = curr->nextNode->number;
                   curr->nextNode->number = value;
                   swapped = true;
               }

               curr = curr->nextNode;
           }
       }
   }
}

// function to return the element at index from the list
int& LinkedList::operator [](const int &index)
{
   if(head->nextNode == tail) // empty list
   {
       cout<<"Index out of bounds"<<endl;
       return head->number;
   }else
   {
       int pos = index; // set pos to index
       Node *curr = head->nextNode; // set curr to first node
       // loop to get the node at pos
       while(curr != tail && pos > 0)
       {
           curr = curr->nextNode;
           pos--;
       }
       // valid index
       if(pos == 0 && curr != tail)
       {
           return curr->number;
       }else // invalid index
       {
           cout<<"Index out of bounds"<<endl;
           return curr->number;
       }

   }

}

// destructor to delete all the nodes of the list
LinkedList::~LinkedList()
{
   Node *temp;
   while(head != nullptr)
   {
       temp = head;
       head = head->nextNode;
       delete(temp);
   }
}

int main() {

   ifstream fin("Perm_50.txt");
   int value;
   LinkedList list;
   if(fin.is_open())
   {
       while(!fin.eof())
       {
           fin>>value;
           list.addNodeToEnd(value);
       }

       fin.close();

       cout<<"List forward :"<<endl;
       list.printListForward();
       list.sort();
       cout<<"List backward : "<<endl;
       list.printListBackward();
       list[2] = 66;
       cout<<"List forward :"<<endl;
       list.printListForward();

   }else
       cout<<"Unable to open file Perm_50.txt"<<endl;
   return 0;
}
//end of program

Output:

Input file:

21 33 12. 67 8 1 190 120 7 12 88 6 3 15 45

Output:

List forward : 21 33 12 67 8 1 90 120 7 12 88 6 3 15 45 List backward : 120 90 88 67 45 33 21 15 12 12 8 7 6 3 1 List forward : 1 3 66 7 8 12 12 15 21 33 45 67 88 90 120