列表类(c++)

template <class DataType>
struct Node
{
 DataType info;
 Node<DataType> *next;
};

template <class DataType>
class LinkedList
{
public:
 LinkedList();
 ~LinkedList();
 LinkedList(const LinkedList<DataType> &copy);
 LinkedList<DataType>& operator=(const LinkedList<DataType> &right);
 void Insert(const DataType &element);
 bool Remove(DataType &element);
 bool Retrieve(DataType &element);
 bool Find(const DataType &element);
 bool Replace(const DataType &element);
 bool IsEmpty()const;
 void MakeEmpty();
 

private:
 inline bool first(DataType &element);
 inline bool getNext(DataType &element);
 inline void DeepCopy(const LinkedList<DataType> &origin);
 Node<DataType> *header;
    Node<DataType> *current;
};

template <class DataType>
LinkedList<DataType>::LinkedList()
{
 header = NULL;
}

template <class DataType>
LinkedList<DataType>::~LinkedList()
{
 MakeEmpty();
}

template <class DataType>
LinkedList<DataType>::LinkedList(const LinkedList<DataType> &copy)
{
 DeepCopy(copy);
}

template <class DataType>
LinkedList<DataType>& LinkedList<DataType>::operator=(const LinkedList<DataType> &right)
{
 if(&right == this)
 {
  return *this;
 }
 MakeEmpty();
 DeepCopy();
 return *this;
}

template <class DataType>
void LinkedList<DataType>::Insert(const DataType &element)
{
 current = NULL;
 if(NULL == header)
 {
  header = new Node<DataType>;
  header->info = element;
  header->next = NULL;  //NULL结束标记就像字符串里的/0一样很重要。
  return;
 }
 Node<DataType> *temp = new Node<DataType>;
 temp->info = element;
 temp->next = header;
 header = temp;
}

template <class DataType>
bool LinkedList<DataType>::Remove(DataType &element)
{
 current = NULL;
 Node<DataType> *temp = header;
 if(header->info == element)
 {
  header = header->next;
  element = temp->info;
  delete temp;
  return true;
 }
 while(temp->next != NULL)
 {
  if(temp->next->info == element)
  {
   Node<DataType> *del = temp->next;
   element = del->info;
   temp->next = del->next;
   delete del;
   return true;
  }
  temp = temp->next;
 }
 return false;
}

template <class DataType>
bool LinkedList<DataType>::Retrieve(DataType &element)
{
 if(!Find(element))
 {
  return false;
 }
 element = current->info;
 return true;
}

template <class DataType>
bool LinkedList<DataType>::Find(const DataType &element)
{
 DataType temp;
 if(!first(temp))
 {
  return false;
 }
 do
 {
  if(temp == element)
  {
   return true;
  }
 } while (getNext(temp));
 return false;
}
template <class DataType>

bool LinkedList<DataType>::Replace(const DataType &element)
{
 if(NULL == current)
 {
  return false;
 }
 current->info = element;
 return true;
}

template <class DataType>
bool LinkedList<DataType>::IsEmpty()const
{
 return NULL == header;
}

template <class DataType>

void LinkedList<DataType>::MakeEmpty()
{
 while(NULL != header)
 {
  current = header;
  header = header->next;
  delete current;
 }
 current = NULL;
}

template <class DataType>
inline bool LinkedList<DataType>::first(DataType &element)
{
 if(NULL == header)
 {
  current = NULL;
  return false;
 }
 current = header;
 element = current->info;
 return true;
}

template <class DataType>
inline bool LinkedList<DataType>::getNext(DataType &element)
{
 if(NULL == current)
 {
  return false;
 }
 if(NULL == current->next)
 {
  current = NULL;
  return false;
 }
 current = current->next;
 element = current->info;
 return true;
}

template <class DataType>
inline void LinkedList<DataType>::DeepCopy(const LinkedList<DataType> &origin)
{
 header = current = NULL;
 if(NULL == origin.header)
 {
  return;
 }
 header = origin.header;
 header->info = origin.header->info;
 if(origin.header->info == origin.current)
 {
  current = header;
 }
 Node<DataType> *copy = header;
 Node<DataType> *originptr = origin.header;
 while(originptr->next != NULL)
 {
  originptr = originptr->next;
  copy->next = new Node<DataType>;
  copy = copy->next;
  copy->info = originptr->info;
  if(originptr == origin.current)
  {
   current = copy;
  }
 }
 header->next = NULL;
}

int main()
{
 LinkedList<int> arr;
 for(int i=0; i<20; i++)
 {
  arr.Insert(i);
 }

 for(int k=0; k<20; k++)
 {
  cout<<"  "<<arr.Remove(k);
 }
     
 cout<<endl;
 cout<<arr.Find(i=3);
 return 0;
}