链表

//头文件：
//顺序存储方式：
#include <iostream.h>
template <class T>
class LinearList
{
 private:  
  int MaxSize;
  int length;
  T *element;
 public:
  LinearList(int maxListSize = 10);
  ~LinearList() {delete [] element;}
  bool IsEmpty() const {return length == 0;}
  bool IsFull() const {return length == MaxSize;}
  int Length() const {return length;}
  bool Find(int k, T &item) const;
  int Search(const T &item) const;
  void Delete(int k, T &item);
  void Insert(int k, const T &item); 
};
//源文件：
#include "LinearList.h"
template <class T>
LinearList<T>::LinearList(int maxListSize)
{
 MaxSize = maxListSize;
 element = new T[MaxSize];
 length = 0;
}
template <class T>
bool LinearList<T>::Find(int k, T &item) const
{
 if( k < 0 || k > length - 1 || length == 0) 
 { 
  cout<<"unreasonabe position!"<<endl;
  return false;
 }
 item = element[k];
 return true;
}
template <class T>
int LinearList<T>::Search(const T &item) const
{
 for(int i = 0; i < length; i++)
  if(item == element[i])
   return i;
 return -1;
}
template <class T>
void LinearList<T>::Delete(int k, T &item)
{
 for(int i = k+1; i < length; i++)
  element[i-1] = element[i];
 length--;
 return;
}
template <class T>
void LinearList<T>::Insert(int k, const T &item)
{
 if(IsFull ())
 {
  cout<<"The list is full"<<endl;
  exit(1);
 }
 if(k < 0 || k > length-1)
 {
  cout<<"The node does not exist"<<endl;
  exit(1);
 }
 for(int i = length - 1; i >= k + 1; i --)
 {
  element[i+1] = element[i];
 }
 element[K+1] = item;
 length ++;
 return;
}
//单链表：链式存储
//头文件：
#include <iostream.h>
#ifndef SLNODE
#define SLNODE
template <class T>
struct SLNode
{
 T data;
 SLNode<T> *next; 
 
 SLNode (SLNode *nextNode = NULL) {next = nextNode;}
 SLNode (const T& item, SLNode *nextNode = NULL ) {data = item; next = nextNode;}
};
template <class T>
class SLList
{
private:
 SLNode <T> *head;
 SLNode <T> *tail;
 SLNode <T> *currptr;
 
 int size;
 
public:
 SLList (void);
 
 SLList (T &item);
 ~SLList(void);
 
 void SetEnd();
 
 void Prev();
 
 bool IsEmpty(void) const {return head->next == NULL;}
 
 int length(void) const {return size;}
 
 bool Find(int k, T &item) const;
 
 int Search(const T &item) const;
 
 void Delete(int k, T &item);
 
 bool Delete(T &de_item);
 
 bool DeleteFromHead(T &de_item);
 
 bool DeleteFromTail(T &de_item);
 
 void Insert(const T &item);
 
 void InsertFromHead(const T &item);
 
 void InsertFromTail(const T &item);
};
#endif
//源文件：
#include "SLList.h"
template <class T>
SLList<T>::SLList()
{
 head = tail = currptr = new SLNode <T>();
 size = 0;
}
template <class T>
SLList<T>::SLList(T &item)
{
 tail = currptr = new SLNode <T>(item);
 head = new SLnode <T>(currptr);
 size = 1;
}
template <class T>
SLList<T>::~SLList()
{
 while(!IsEmpty())
 {
  currptr = head->next;
  head->next = currptr->next;
  delete currptr;
 }
 delete head;
}
template <class T>
void SLList<T>::SetEnd()
{
 currptr = tail;
}
template <class T>
void SLList<T>::Prev()
{
 SLNode <T>*temp = head;
 for(; temp != NULL; )
  if(temp->next == currptr)
  {
   currptr = temp;
   break;
  }
}
template <class T>
void SLList<T>::Insert(const T &item)
{
 currptr->next = new SLNoode <T>(item, currptr->next); 
 if(tail == currptr)
  tail = currptr->next;
 size ++;
}
template <class T>
bool SLList<T>::Delete(T &de_item)//删除当前结点的后继结点将其data值返回给变量de_item
{
 if(currptr == tail || IsEmpty())
 {
  cout<<"No next node or empty list!"<<endl;
  return false;
 }
 SLNode <T>*temp = currptr->next;
 currptr->next = temp->next;
 size --;
 de_item = temp->data;
 if(temp == tail)
  tail = currptr;
 delete temp;
 return true;
}
template <class T>
bool SLList<T>::DeleteFromHead(T &de_item)
{
 if(IsEmpty())
 {
  cout<<"Empty List!"<<endl;
  return false;
 }
 SLNode <T> *temp = head->next;
 head->next = temp->next;
 size --;
 if(temp == tail) tail = head;
 delete temp;
 return true;
}
template <class T>
bool SLList<T>::DeleteFromTail(T &de_item)
{
 if(IsEmpty())
 {
  cout<<"Empty list!"<<endl;
  return false;
 }
 SetEnd();
 Prev();
 de_item = tail->data;
 currptr->next = NULL;
 size --;
 delete tail;
 tail = currptr;
 return true;
}

template <class T>
void SLList<T>::InsertFromHead(const T &item)
{
 if(IsEmpty())
 {
  head->next = new SLNode <T>(item, head->next);
  tail = head->next;
 }
 else 
  head->next = new SLNode <T>(item, head->next);
 size ++;
}
template <class T>
void SLList<T>::InsertFromTail(const T &item)
{
 tail->next = new SLNode <T>(item, NULL);
 tail = tail->next;
 size ++;
}
//双链表：链式存储：
//头文件：
#include "SLList.h"
template <class T>
struct DLNode
{
 T data;
 DLNode <T> *left, *right;
 DLNode() {left = right = NULL;}
 DLNode(const T &item, SLNode *L = NULL, SLNode *R = NULL)
 {
  data = item;
  left = L;
  right = R;
 }
};
template <class T>
class DLList
{
private:
 DLNode <T> *head;
 DLNode <T> *tail;
 DLNode <T> *currptr;
 int size;
public:
 DLList (void);
 DLList (T &item);
 ~DLList(void);
 bool IsEmpty(void) const;
 int length(void) const {return size;}
 bool Find(int k, T &item) const;
 int Search(const T &item) const;
 void Delete(int k, T &item);
 bool Delete(T &de_item);
 bool DeleteFromHead(T &de_item);
 bool DeleteFromTail(T &de_item);
 bool DeleteFromCur(T &de_item);
 void Insert(const T &item);
 void InsertFromHead(const T &item);
 void InsertFromTail(const T &item);
 bool DeleteRight(T &de_item);
};
//源文件：
#include "DList.h"

template <class T>
bool DLList<T>::IsEmpty(void) const
{
 return head->right == NULL;
}
template <class T>
void DLList<T>::Insert(const T &item)
{
 if(IsEmpty())
 {
  tail = head->right = new DLNode<T> (item, head, NULL);
  size ++;
  return;
 }
 DLNode *p = new DLNode <T>(item, currptr, currptr->right);
 currptr->right->left = p;
 currptr->right = p;
 size ++;
 if(currptr == tail) tail = p;
}
template <class T>
void DLList<T>::InsertFromTail(const T &item)
{
 tail = tail->right = new DLNode<T> (item, tail, NULL);
 size++;
}
template <class T>
void DLList<T>::InsertFromHead(const T &item)
{
 if (IsEmpty())
 {
  tail = head->right = new DLNode <T> (item, head, NULL);
  size ++;
  return;
 }
 DLNode *p = new DLNode<T> (item, head, head->right); //1,2 steps finished
 head->right->left = p;//3 step
 head->right = p;//4 step
 size++; 
}
template <class T>
bool DLList<T>::DeleteFromTail(T &de_item)
{
 if(IsEmpty() || currptr == head) return false;
 de_item = currptr->data;
 currptr->left->right = currptr->right;
 if (currptr == tail)
 {
  tail = currptr->left;
 }
 else
 {
  currptr->right->left = currptr->left;
 }
 size --;
 currptr = currptr->left;
 delete currptr->right; //delete current point 
}
template <class T>
bool DLList<T>::DeleteFromHead(T &de_item)
{
 if (IsEmpty())
 {
  cout<<"Empty list"<<endl;
  return false;
 }
 DLNode <T> *temp = head->right;
 head->right = temp->right;
 size -- ;
 de_item = temp->data;
 if (temp == tail) tail = head;
 delete temp;
 return true; 
}
template <class T>
bool DLList<T>::DeleteFromCur(T &de_item)
{
 if (IsEmpty())
 {
  cout<<"Empty List"<<endl;
  return false;
 }
 DLNode <T> *temp = currptr = tail;
 currptr = currptr->left;
 de_item = tail->data;
 currptr->right = NULL;
 size --;
 delete temp; //i modify think of not deleting tail point
 tail = currptr;
 return true;
}
template <class T>
bool DLList<T>::DeleteRight(T &de_item)//delete right node of current node
{
 if (IsEmpty() || currptr->right == NULL) return;
 
 DLNode <T> *temp = currptr->right;
 de_item = temp->data;
 if (tail == temp) tail = currptr;
 else
  temp->right->left = currptr;
 currptr->right = temp->right;
 delete temp;
 size --;
 return false;
}