Recursive remove in linked list - c++

Question

I am trying to remove the element from linked list recursively, but the remove function is not working. I need some help in solving this.
My node.h function
#ifndef NODE_
#define NODE_
template<class ItemType>
class Node {
private:
ItemType item; // A data item
Node<ItemType>* next; // Pointer to next node
public:
Node();
Node(const ItemType& anItem);
Node(const ItemType& anItem, Node<ItemType>* nextNodePtr);
void setItem(const ItemType& anItem);
void setNext(Node<ItemType>* nextNodePtr);
ItemType getItem() const;
Node<ItemType>* getNext() const;
}; // end Node
#include "Node.cpp"
#endif
My node.cpp file:
#include "Node.h"
template<class ItemType>
Node<ItemType>::Node() : next(nullptr)
{
} // end default constructor
template<class ItemType>
Node<ItemType>::Node(const ItemType& anItem) : item(anItem), next(nullptr)
{
} // end constructor
template<class ItemType>
Node<ItemType>::Node(const ItemType& anItem, Node<ItemType>* nextNodePtr) :
item(anItem), next(nextNodePtr)
{
} // end constructor
template<class ItemType>
void Node<ItemType>::setItem(const ItemType& anItem)
{
item = anItem;
} // end setItem
template<class ItemType>
void Node<ItemType>::setNext(Node<ItemType>* nextNodePtr)
{
next = nextNodePtr;
} // end setNext
template<class ItemType>
ItemType Node<ItemType>::getItem() const
{
return item;
} // end getItem
template<class ItemType>
Node<ItemType>* Node<ItemType>::getNext() const
{
return next;
} // end getNext
My main function:
#include <iostream>
#include "Node.h"
using namespace std;
// Function to insert an item into the front of a linked list
template<class T>
void insert(Node<T>* &headPtr, const T& entry)
{
// Create a new node and have the next pointer point to current front
Node<T> *newNodePtr = new Node<T>( entry , headPtr );
// Current front now becomes this new node
headPtr = newNodePtr;
}
// Recursive function to remove an item from a linked list
// Returns true if the operation was done; false, otherwise
template< typename T >
bool removes(Node<T>* &nodePtr, T target)
{
if(!nodePtr)
{
return false;
}
if(nodePtr->getNext() != NULL)
{
Node<T>*next = nodePtr->getNext();
removes(next,target);
if(nodePtr->getNext()->getItem()==target)
{
Node<T>*del = nodePtr;
nodePtr->setNext(nodePtr->getNext()->getNext());
delete del;
return true;
}
//nodePtr->setNext(nodePtr->getNext());
}
}
// Recursive function to display the contents of a linked list
// in the reverse order.
template<class T>
void display(Node<T> *currNodePtr)
{
// YOUR CODE GOES HERE - CHECK YOUR NOTES!
Node<T> *curr=currNodePtr;
if(curr!=NULL)
{
cout<<curr->getItem();
display(curr->getNext());
}
cout<<endl;
}
int main()
{
// (1) Declare an empty linked list of unsigned values
// based on the Node class and call it myList
Node<unsigned>*myList;
// (2) Read in values from standard input. Non-negative
// values are inserted into myList and a negative
// value terminates input.
int data=0;
unsigned k;
while(cin>>data)
{
if (data>=0)
{
k=data;
insert(myList,k);
}
else
{
break;
}
}
cout<<"out of loop";
// (3) Display the contents of the linked list myList
// in the order they were entered (hence, the display()
// function displays myList in reverse order!
display(myList);
// (4) Read in values from standard input. Non-negative
// values are removed from myList and a negative
// value terminates input.
int data1=0;
unsigned m;
while(cin>>data1)
{
if (data1>=0)
{
m=data1;
removes(myList,m);
}
else
{
break;
}
}
// (5) Display the contents of the linked list myList
// in the order they were entered (hence, the display()
// function displays myList in reverse order!
cout<<endl;
display(myList);
}
The remove function is in main. It is not removing the correct element. For example, in the list of 1 2 3 4 5, if I try to remove 3 it is removing 2.