delete all copies of an item in a unsorted linked list

I missed the class on linked list because I was sick and I'm still really sick but I have to turn in this assignment soon and I have no idea how to change the DeleteItem function so that it does not do anything when an item is not in the list and also makes sure to delete ALL of the copies of the item within the list. I just need help figuring out how to do this part so if someone could explain how to do it I'd really appreciate it because I've been looking at it for hours, reading my textbook, watching tutorials, and I still can't figure this out.
Here is the file containing the DeleteItem function we are suppose to change:

// This file contains the linked implementation of class
// UnsortedType.

#include "UnsortedType.h"

struct NodeType
{
   ItemType info;
   NodeType* next;
};


UnsortedType::UnsortedType()  // Class constructor
{
   length = 0;
   listData = NULL;
}


bool UnsortedType::IsFull() const
// Returns true if there is no room for another ItemType 
//  on the free store; false otherwise.
{
   NodeType* location;
   try
   {
      location = new NodeType;
      delete location;
      return false;
   }
   catch(std::bad_alloc exception)
   {
      return true;
   }
}


int UnsortedType::GetLength() const
// Post: Number of items in the list is returned.
{
   return length;
}


void UnsortedType::MakeEmpty()
// Post: List is empty; all items have been deallocated.
{
   NodeType* tempPtr;

   while (listData != NULL)
   {
      tempPtr = listData;
      listData = listData->next;
      delete tempPtr;
   }
   length = 0;
}


void UnsortedType::PutItem(ItemType item)
// item is in the list; length has been incremented.
{
   NodeType* location;		// Declare a pointer to a node

   location = new NodeType;	// Get a new node 
   location->info = item;	// Store the item in the node
   location->next = listData;	// Store address of first node 
 				//   in next field of new node
   listData = location;		// Store address of new node into
				//   external pointer
   length++;			// Increment length of the list
}


ItemType UnsortedType::GetItem(ItemType& item, bool& found)
// Pre:  Key member(s) of item is initialized.
// Post: If found, item's key matches an element's key in the 
//       list and a copy of that element has been stored in item;
//       otherwise, item is unchanged. 
{
   bool moreToSearch;
   NodeType* location;

   location = listData;
   found = false;
   moreToSearch = (location != NULL);

   while (moreToSearch && !found) 
   {
      switch (item.ComparedTo(location->info))
      {
         case LESS    : 
         case GREATER : location = location->next;
                        moreToSearch = (location != NULL);
                        break;
         case EQUAL   : found = true;
                        item = location->info;
                        break;
      }
   }
   return item;
}


void UnsortedType::DeleteItem(ItemType item)
// Pre:  item's key has been initialized.
//       An element in the list has a key that matches item's.
// Post: No element in the list has a key that matches item's.
{
   NodeType* location = listData;
   NodeType* tempLocation = NULL;

   // Locate node to be deleted.
   if (item.ComparedTo(listData->info) == EQUAL)
   {
      tempLocation = location;
      listData = listData->next;		// Delete first node.
   }
   else
   {
      while (item.ComparedTo((location->next)->info) != EQUAL)
         location = location->next;

      // Delete node at location->next
      tempLocation = location->next;
      location->next = (location->next)->next;
   }
   delete tempLocation;
   length--;
}


void UnsortedType::ResetList()
// Post: Current position has been initialized.
{
   currentPos = NULL;
}
 

ItemType UnsortedType::GetNextItem()
// Post:  A copy of the next item in the list is returned.
//        When the end of the list is reached, currentPos
//        is reset to begin again.
{
   ItemType item;
   if (currentPos == NULL)
      currentPos = listData;
   else
      currentPos = currentPos->next;
   item = currentPos->info;
   return item;
}

void UnsortedType::SplitLists(ItemType item, UnsortedType& list1, UnsortedType& list2)
// Pre:
// Post:
{
	int length = GetLength();
	list1.MakeEmpty();
	list2.MakeEmpty();
	
	ResetList();
	
	//for (int index = 0; index <= length; index++)
	while(length != 0)
	{
		ItemType temp = GetNextItem();
		if (temp.ComparedTo(item) == EQUAL || temp.ComparedTo(item) == LESS)
		{
			list1.PutItem(temp);
		}
		else if (temp.ComparedTo(item) == GREATER)
		{
			list2.PutItem(temp);
		}
		length--;
	}
}

UnsortedType::~UnsortedType()
// Post: List is empty; all items have been deallocated.
{
   NodeType* tempPtr;

   while (listData != NULL)
   {
      tempPtr = listData;
      listData = listData->next;
      delete tempPtr;
   }
}

And just in case you need it here is the .h file that matches that .cpp file and the ItemType.h and ItemType.cpp

UnsortedType.h

#include "ItemType.h" 
// File ItemType.h must be provided by the user of this class. 
//  ItemType.h must contain the following definitions: 
//  MAX_ITEMS:     the maximum number of items on the list 
//  ItemType:      the definition of the objects on the list 
//  RelationType:  {LESS, GREATER, EQUAL}
//  Member function ComparedTo(ItemType item) which returns 
//       LESS, if self "comes before" item 
//       GREATER, if self "comes after" item 
//       EQUAL, if self and item are the same 

class UnsortedType 
{
   public:
      UnsortedType();
      // Constructor
  
      void MakeEmpty();
      // Function: Returns the list to the empty state.
      // Post:  List is empty.
  
      bool IsFull() const;
      // Function:  Determines whether list is full.
      // Pre:  List has been initialized.
      // Post: Function value = (list is full)

      int GetLength() const;
      // Function: Determines the number of elements in list.
      // Pre:  List has been initialized.
      // Post: Function value = number of elements in list

      ItemType GetItem(ItemType, bool&);
      // Function: Retrieves list element whose key matches item's key (if
      //           present).
      // Pre:  List has been initialized.
      //       Key member of item is initialized.
      // Post: If there is an element someItem whose key matches
      //       item's key, then found = true and someItem is returned.
      // 	 otherwise found = false and item is returned.
      //       List is unchanged.

      void PutItem(ItemType item);
      // Function: Adds item to list.
      // Pre:  List has been initialized.
      //       List is not full.
      //       item is not in list.
      // Post: item is in list.

      void DeleteItem(ItemType item);
      // Function: Deletes the element whose key matches item's key.
      // Pre:  List has been initialized.
      //       Key member of item is initialized.
      //       One and only one element in list has a key matching item's key.
      // Post: No element in list has a key matching item's key.

      void ResetList();
      // Function: Initializes current position for an iteration through the list.
      // Pre:  List has been initialized.
      // Post: Current position is prior to list.

      ItemType GetNextItem();
      // Function: Gets the next element in list.
      // Pre:  List has been initialized and has not been changed since last call.
      //       Current position is defined.
      //       Element at current position is not last in list.
      //	     
      // Post: Current position is updated to next position.
      //       item is a copy of element at current position.
	  
	  void SplitLists(ItemType item, UnsortedType& list1, UnsortedType& list2);
	  // Function: Divides list into two lists according to the key of item.
	  // Pre: list has been initialized and is not empty.
	  // Post: list1 contains all the items of list whose keys are less than 
	  //       or equal to item's key; list2 contains all the items of list 
	  //       whose keys are greater than item's key.

   private:
      int length;
      ItemType info[MAX_ITEMS];
      int currentPos;
};

ItemType.h

#include <fstream>
const int MAX_ITEMS = 5;
enum RelationType  {LESS, GREATER, EQUAL};

class ItemType 
{ 
   public:
      ItemType();
      RelationType ComparedTo(ItemType) const;
      void Print(std::ostream&) const;
      void Initialize(int number);
   private:
      int value;
};

ItemType.cpp

// The following definitions go into file ItemType.cpp. 
#include <fstream>
#include <iostream>
#include "ItemType.h"

ItemType::ItemType()
{ 
   value = 0;
}

RelationType ItemType::ComparedTo(ItemType otherItem) const 
{
   if (value < otherItem.value)
      return LESS;
   else if (value > otherItem.value)
      return GREATER;
   else return EQUAL;
}

void ItemType::Initialize(int number) 
{
   value = number;
}

void ItemType::Print(std::ostream& out) const 
// pre:  out has been opened.
// post: value has been sent to the stream out.
{
   out << value;
}

Thanks in advance for any and all help.