In c++ Design your own linked list class to hold a series of integers. The class should have member functions for appending, inserting, and deleting nodes. Dont forget to add a destructor that destroys the list. Demonstrate the class with a driver program. This is what I have so far. but I dont know what Ive done wrong?

this is my LinkedList.h file

// A class template for holding a linked list.

// The node type is also a class template.

#ifndef LINKEDLIST_H

#define LINKEDLIST_H

//*********************************************

// The ListNode class creates a type used to *

// store a node of the linked list. *

//*********************************************

template

class ListNode

{

public:

T value; // Node value

ListNode *next; // Pointer to the next node

// Constructor

ListNode (T nodeValue)

{ value = nodeValue;

next = nullptr;}

};

//*********************************************

// LinkedList class *

//*********************************************

template

class LinkedList

{

private:

ListNode *head; // List head pointer

public:

// Constructor

LinkedList()

{ head = nullptr; }

// Destructor

~LinkedList();

// Linked list operations

void appendNode(T);

void insertNode(T);

void deleteNode(T);

void displayList() const;

};

//**************************************************

// appendNode appends a node containing the value *

// pased into newValue, to the end of the list. *

//**************************************************

template

void LinkedList::appendNode(T newValue)

{

ListNode *newNode; // To point to a new node

ListNode *nodePtr; // To move through the list

// Allocate a new node and store newValue there.

newNode = new ListNode(newValue);

// If there are no nodes in the list

// make newNode the first node.

if (!head)

head = newNode;

else // Otherwise, insert newNode at end.

{

// Initialize nodePtr to head of list.

nodePtr = head;

// Find the last node in the list.

while (nodePtr->next)

nodePtr = nodePtr->next;

// Insert newNode as the last node.

nodePtr->next = newNode;

}

}

//**************************************************

// displayList shows the value stored in each node *

// of the linked list pointed to by head. *

//**************************************************

template

void LinkedList::displayList() const

{

ListNode *nodePtr; // To move through the list

// Position nodePtr at the head of the list.

nodePtr = head;

// While nodePtr points to a node, traverse

// the list.

while (nodePtr)

{

// Display the value in this node.

cout << nodePtr->value << endl;

// Move to the next node.

nodePtr = nodePtr->next;

}

}

//**************************************************

// The insertNode function inserts a node with *

// newValue copied to its value member. *

//**************************************************

template

void LinkedList::insertNode(T newValue)

{

ListNode *newNode; // A new node

ListNode *nodePtr; // To traverse the list

ListNode *previousNode = nullptr; // The previous node

// Allocate a new node and store newValue there.

newNode = new ListNode(newValue);

// If there are no nodes in the list

// make newNode the first node

if (!head)

{

head = newNode;

newNode->next = nullptr;

}

else // Otherwise, insert newNode

{

// Position nodePtr at the head of list.

nodePtr = head;

// Initialize previousNode to nullptr.

previousNode = nullptr;

// Skip all nodes whose value is less than newValue.

while (nodePtr != nullptr && nodePtr->value < newValue)

{

previousNode = nodePtr;

nodePtr = nodePtr->next;

}

// If the new node is to be the 1st in the list,

// insert it before all other nodes.

if (previousNode == nullptr)

{

head = newNode;

newNode->next = nodePtr;

}

else // Otherwise insert after the previous node.

{

previousNode->next = newNode;

newNode->next = nodePtr;

}

}

}

//*****************************************************

// The deleteNode function searches for a node *

// with searchValue as its value. The node, if found, *

// is deleted from the list and from memory. *

//*****************************************************

template

void LinkedList::deleteNode(T searchValue)

{

ListNode *nodePtr; // To traverse the list

ListNode *previousNode; // To point to the previous node

// If the list is empty, do nothing.

if (!head)

return;

// Determine if the first node is the one.

if (head->value == searchValue)

{

nodePtr = head->next;

delete head;

head = nodePtr;

}

else

{

// Initialize nodePtr to head of list

nodePtr = head;

// Skip all nodes whose value member is

// not equal to num.

while (nodePtr != nullptr && nodePtr->value != searchValue)

{

previousNode = nodePtr;

nodePtr = nodePtr->next;

}

// If nodePtr is not at the end of the list,

// link the previous node to the node after

// nodePtr, then delete nodePtr.

if (nodePtr)

{

previousNode->next = nodePtr->next;

delete nodePtr;

}

}

}

//**************************************************

// Destructor *

// This function deletes every node in the list. *

//**************************************************

template

LinkedList::~LinkedList()

{

ListNode *nodePtr; // To traverse the list

ListNode *nextNode; // To point to the next node

// Position nodePtr at the head of the list.

nodePtr = head;

// While nodePtr is not at the end of the list...

while (nodePtr != nullptr)

{

// Save a pointer to the next node.

nextNode = nodePtr->next;

// Delete the current node.

delete nodePtr;

// Position nodePtr at the next node.

nodePtr = nextNode;

}

}

#endif

This is my NumberList.h file

// Specification file for the NumberList class #ifndef NUMBERLIST_H #define NUMBERLIST_H

class NumberList { private: // Declare a structure for the list struct ListNode { double value; // The value in this node struct ListNode *next; // To point to the next node };

ListNode *head; // List head pointer

public: // Constructor NumberList() { head = nullptr; } // Destructor ~NumberList(); // Linked list operations void appendNode(double); void insertNode(double); void deleteNode(double); void displayList() const; }; #endif

And my driver program

// Implementation file for the NumberList class

#include // For cout

#include "NumberList.h"

using namespace std;

//**************************************************

// appendNode appends a node containing the *

// value pased into num, to the end of the list. *

//**************************************************

void NumberList::appendNode(double num)

{

ListNode *newNode; // To point to a new node

ListNode *nodePtr; // To move through the list

// Allocate a new node and store num there.

newNode = new ListNode;

newNode->value = num;

newNode->next = nullptr;

// If there are no nodes in the list

// make newNode the first node.

if (!head)

head = newNode;

else // Otherwise, insert newNode at end.

{

// Initialize nodePtr to head of list.

nodePtr = head;

// Find the last node in the list.

while (nodePtr->next)

nodePtr = nodePtr->next;

// Insert newNode as the last node.

nodePtr->next = newNode;

}

}

//**************************************************

// displayList shows the value *

// stored in each node of the linked list *

// pointed to by head. *

//**************************************************

void NumberList::displayList() const

{

ListNode *nodePtr; // To move through the list

// Position nodePtr at the head of the list.

nodePtr = head;

// While nodePtr points to a node, traverse

// the list.

while (nodePtr)

{

// Display the value in this node.

cout << nodePtr->value << endl;

// Move to the next node.

nodePtr = nodePtr->next;

}

}

//**************************************************

// The insertNode function inserts a node with *

// num copied to its value member. *

//**************************************************

void NumberList::insertNode(double num)

{

ListNode *newNode; // A new node

ListNode *nodePtr; // To traverse the list

ListNode *previousNode = nullptr; // The previous node

// Allocate a new node and store num there.

newNode = new ListNode;

newNode->value = num;

// If there are no nodes in the list

// make newNode the first node

if (!head)

{

head = newNode;

newNode->next = nullptr;

}

else // Otherwise, insert newNode

{

// Position nodePtr at the head of list.

nodePtr = head;

// Initialize previousNode to nullptr.

previousNode = nullptr;

// Skip all nodes whose value is less than num.

while (nodePtr != nullptr && nodePtr->value < num)

{

previousNode = nodePtr;

nodePtr = nodePtr->next;

}

// If the new node is to be the 1st in the list,

// insert it before all other nodes.

if (previousNode == nullptr)

{

head = newNode;

newNode->next = nodePtr;

}

else // Otherwise insert after the previous node.

{

previousNode->next = newNode;

newNode->next = nodePtr;

}

}

}

//**************************************************

// The deleteNode function searches for a node *

// with num as its value. The node, if found, is *

// deleted from the list and from memory. *

//**************************************************

void NumberList::deleteNode(double num)

{

ListNode *nodePtr; // To traverse the list

ListNode *previousNode; // To point to the previous node

// If the list is empty, do nothing.

if (!head)

return;

// Determine if the first node is the one.

if (head->value == num)

{

nodePtr = head->next;

delete head;

head = nodePtr;

}

else

{

// Initialize nodePtr to head of list

nodePtr = head;

// Skip all nodes whose value member is

// not equal to num.

while (nodePtr != nullptr && nodePtr->value != num)

{

previousNode = nodePtr;

nodePtr = nodePtr->next;

}

// If nodePtr is not at the end of the list,

// link the previous node to the node after

// nodePtr, then delete nodePtr.

if (nodePtr)

{

previousNode->next = nodePtr->next;

delete nodePtr;

}

}

}

//**************************************************

// Destructor *

// This function deletes every node in the list. *

//**************************************************

NumberList::~NumberList()

{

ListNode *nodePtr; // To traverse the list

ListNode *nextNode; // To point to the next node

// Position nodePtr at the head of the list.

nodePtr = head;

// While nodePtr is not at the end of the list...

while (nodePtr != nullptr)

{

// Save a pointer to the next node.

nextNode = nodePtr->next;

// Delete the current node.

delete nodePtr;

// Position nodePtr at the next node.

nodePtr = nextNode;

}

}