Linked Lists

[swaveysaiyan]

I can't figure out what I am doing wrong

I'm following an example but I keep getting errors the ones I can see are in my linkeList.cpp file. and the more I keep trying to figure it the more errors that keep coming up

  //main.cpp
#include "header.h"
#include "linkedList.cpp"

int main()
{
   cout << "*************************PROGRAM*********************************";
   cout << "\nFind and Delete the node with the smallest info in the list and"
       << "\nFind and Delete all occurrences of a given info from the list .";
  
   unorderedLinkedList<int> myList;
  
   cout << "\n\nInserting random numbers into the list.";
   myList.insertFirst(3);
   myList.insertFirst(15);
   myList.insertFirst(22);
   myList.insertLast(1);
   myList.insertFirst(31);
   myList.insertFirst(48);
   myList.insertFirst(57);
   myList.insertFirst(87);
   myList.insertFirst(67);
   cout << "\n\n\tThe elements in the list : ";
   myList.print();
   
   cout << "\n\tDeleting all occurrences of the smallest element.";
   myList.deleteAllSmall();
  
   cout << "\n\n\tThe elements in the list : ";
   myList.print();
  
   cout << "\n\tDeleting first occurrence of the smallest element.";
   myList.deleteSmallest();
  
   cout << "\n\n\tThe elements in the list : ";
   myList.print();
   cout << "\n\n\t";
   
   system("pause");
   return 0;
}
//header.h
#include<iostream>
using std::cout;
using std::cin;
#ifndef H_NodeType
#define H_NodeType
template<class Type>
struct nodeType
{
   Type info;
   nodeType<Type> *link;
};
#endif


template <class Type>
class linkedListIterator
{
public:
   
   linkedListIterator();
  
   linkedListIterator(nodeType<Type> *ptr);
   Type operator*();

  linkedListIterator<Type> operator++();
  bool operator==(const linkedListIterator<Type> &right) const;
  bool operator!=(const linkedListIterator<Type> &right) const;

private:
   
   nodeType<Type> *current;
};


template<class Type>
linkedListIterator<Type>::linkedListIterator()
{
   current = NULL;
}
template<class Type>
linkedListIterator<Type>::linkedListIterator
(nodeType<Type> *ptr)
{
   current = ptr;
} 
template<class Type>
Type linkedListIterator<Type>::operator*()
{
   return current->info;
} 

template<class Type>
linkedListIterator<Type> linkedListIterator<Type>::operator++()
{
   current = current->link;
   return *this;
} 
template<class Type>
bool linkedListIterator<Type>::operator==(const linkedListIterator<Type>& right) const
{
   return (current == right.current);
} 
template<class Type>
bool linkedListIterator<Type>::operator!=(const linkedListIterator<Type>& right) const
{
   return (current != right.current);
} 

[swaveysaiyan]

//linkedList.cpp

template<class Type>
void linkedListType<Type>::print() const
{
   nodeType<Type> *current;

   current = first;

   while (current != NULL)

   {
     cout << current->info << " ";
     current = current->link;
 }

} 

template<class Type>
int linkedListType<Type>::length() const
{
   return count;
} 
template<class Type>

void linkedListType<Type>::destroyList()

{

   nodeType<Type> *temp;

   while (first != NULL)

   { temp = first;
      first = first->link;
      delete temp;
} 
    last = NULL;
    count = 0;

} 

template<class Type>

Type linkedListType<Type>::front() const

{

   assert(first != NULL);
   return first->info;

} 

template<class Type>

Type linkedListType<Type>::back() const

{

   assert(last != NULL);
    return last->info;

} 

template<class Type>

linkedListIterator<Type> linkedListType<Type>::begin()

{

   linkedListIterator<Type> temp(first);

   return temp;

} 

template<class Type>

linkedListIterator<Type> linkedListType<Type>::end()

{
   linkedListIterator<Type> temp(NULL);
   return temp;

} 

template<class Type>

linkedListType<Type>::~linkedListType()

{

   destroyList();

}

template <class Type>

void linkedListType<Type>::copyList

(const linkedListType<Type>& otherList)

{

   nodeType<Type> *newNode;

   nodeType<Type> *current;

   if (first != NULL)

       destroyList();

   if (otherList.first == NULL)

   {

       first = NULL;

       last = NULL;

       count = 0;

   }

   else

   {
       current = otherList.first;
       count = otherList.count;
       first = new nodeType<Type>;
       first->info = current->info;
       first->link = NULL;
       last = first;
       current = current->link;
       
      while (current != NULL)
       {
           newNode = new nodeType<Type>;
           newNode->info = current->info;
           newNode->link = NULL;
           last->link = newNode;
           last = newNode;
           current = current->link;
       } 
   } 
} 

template <class Type>
class unorderedLinkedList : public linkedListType<Type>
{

public:

   bool search(const Type& searchItem) const;
   void insertFirst(const Type& newItem;
   void insertLast(const Type& newItem);
   void deleteNode(const Type& deleteItem);
   void deleteSmallest();
   void deleteAllSmall();
}; 
template <class Type>
bool unorderedLinkedList<Type>::search(const Type& searchItem) const
{
   nodeType<Type> *current;
   current = first;
   while (current != NULL)
       if (current->info == searchItem)
           return true;
       else
           current = current->link;
   return false;
} 


template <class Type>
void unorderedLinkedList<Type>::insertFirst(const Type& newItem)
{

   nodeType<Type> *newNode;
   newNode = new nodeType<Type>;
   newNode->info = newItem;
    newNode->link = first;

   first = newNode;
   count++;
   if (last == NULL)
    last = newNode;

}

template <class Type>

void unorderedLinkedList<Type>::insertLast(const Type& newItem)

{

   nodeType<Type> *newNode;

   newNode = new nodeType<Type>;

   newNode->info = newItem;

   newNode->link = NULL;
   if (first == NULL)
   {

       first = newNode;

       last = newNode;

       count++;

   }

   else

   {

       last->link = newNode;

       last = newNode;

       count++;

   } 

} 

template <class Type>

void unorderedLinkedList<Type>::deleteNode

(const Type& deleteItem)

{
   nodeType<Type> *current;

  

   nodeType<Type> *trailCurrent;

  

   bool found;

   if (first == NULL)

       cout << "\n\tCannot delete from an empty list.";

   else

   {

       if (first->info == deleteItem)

       {

           current = first;

           first = first->link;

           count--;

           if (first == NULL)

               last = NULL;

           delete current;

       }

       else 

       {

           found = false;

           trailCurrent = first;
           current = first->link;
           while (current != NULL && !found)
           {

               if (current->info != deleteItem)

               {

                   trailCurrent = current;
                   current = current->link;

               }

               else

                   found = true;

           }

           if (found)

           {
             trailCurrent->link = current->link;
             count--;
                if (last == current)
                  last = trailCurrent;
                  delete current;
           }

           else

               cout << "\n\tThe item to be deleted is" << "not in the list.";

       } 

   }

} 

template <class Type>

void unorderedLinkedList<Type>::deleteSmallest()

{

 if (first == NULL)

   {

       cout << "\n\tThere were no elements in the list to delete.";

       return;

   } 


   nodeType<Type> *current;

   current = first;

   Type item = current->info;
   
   current = current->link;

  while (current != NULL)
   {
       if (item > current->info)
           item = current->info;
       current = current->link;
   } 


   deleteNode(item);

} 

template <class Type>

void unorderedLinkedList<Type>::deleteAllSmall()
{
   
   {
       cout << "\n\tThere were no elements in the list to delete.";
       return;

   } 

  nodeType<Type> *current;

   current = first;

   Type item = current->info;

   int count = 1;
   
   current = current->link;

   while (current != NULL)
   {
       
       if (current->info == item)
           count++;
       
       if (item > current->info)
       {
           item = current->info;
           count = 1;
       } 
       current = current->link;
   }   
   deleteNode(item);
}