• Unsorted Linked List. A data structure of objects arranged in a linear order. The order is determined by a pointer in each object. This unsorted list must be implemented with pointers. You will then write a client code that will have a function that will take two unsorted lists and perform the union set operation. The resulting new unsorted list will consist of all the unique items from the original two lists with no duplicates.
  • Class Names: ItemType, UnsortedType
    • Attributes:
      • Max items A constant specifying the maximum number of items to be on the list.
      • ItemType A class encapsulating the type of the items in the list.
      • RelationType An enumeration type that consists of LESS, GREATER, EQUAL
      • Front pointer A pointer to the first item in the list
      • Position pointer A pointer to the current position in the list.
    • Methods:
      • Search Search list for a given item.
        • Precondition Given a value to search for and the object has been created.
        • Postcondition A pointer to the location is returned or NULL pointer is return if no such item exists.
      • InsertItem Adds item to the list.
      • DeleteItem Deletes the element whose key matches items key.
      • GetNextItem Updates position pointer to next item in the list.
      • MakeEmpty Initializes list to empty state.
      • IsFull Determines whether list is full.
      • ResetList Initializes current position to front of the list.
      • ComparedTo Determines the ordering of two ItemType objects based on their keys.
      • GetLength Determines the number of elements in list.
      • Union The mathematical set operation of union is performed on two given lists and a new list is created with unique elements from both lists.
  • Please read the question above and write a program. I tried but I couldn't, the following code is mine but it does not work. Please help me with this.

#include

struct NodeType; { ItemType info; NodeType* next;

class UnsortedType { public:

UnsortedType(); void MakeEmpty(); bool IsFull(); int GetLength(); ItemType GetItem(ItemType item, bool& found); void PutItem(ItemType item); void DeleteItem(ItemType item); void ResetList(); ItemType GetNextItem(); private:

NodeType* listData; int length; NodeType* currentPos; }

UnsortedType::UnsortedType() { length = 0;

void UnsortedType::InsertItem(ItemType item); { NodeType* location; location = new NodeType; location->info = item; location->next = listData; listData = location;

length++; } } bool UnsortedType::IsFull() { NodeType* location; { location = new NodeType; delete location; return false; } } int UnsortedType::GetLength()

{ return length; }

void UnsortedType::MakeEmpty() { NodeType* tempPtr; { while (listData != NULL) { tempPtr = listData; listData = listData->next; delete tempPtr; } length = 0; } }

ItemType UnsortedType::GetItem(ItemType item, bool& found)

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

UnsortedType::DeleteItem(ItemType item) { NodeType < ItemType* location = listData; NodeType* templocation;

if (item == listData->info) { tempLocation = location; listData = listData->next; } else {

while (item.ComparedTo(location->next)->info) != EQUAL) location = location->next;

tempLocation = location->next; location->next = (location->next)->next; }

} UnsortedType::ResetList() { currentPos = NULL; } ItemType UnsortedType::GetNextItem() { if (currentPos == NULL) currentPos = listData; else currentPos = currentPos->next; return currentPos->info; }