线性表的链式存储结构及实现——单链表

单链表是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续。

• 链表结点数据类型的定义

template <typename T>
struct Node 
{ 
　　T data; 
　　Node<T> *next;      //此处<T>可以省略
}; 

• 带头结点的单链表
  头结点：如果链表有头节点，则链式结构中的第一个节点称为头结点，其数据域可以存储一些附加信息，如链表长度；其指针域指向链表中的第一个节点。
• 单链表的实现

template <class T>
class LinkList { 
　　public: 
　　LinkList ( ) {first=new Node<T>; first -> next= NULL ;}
　    LinkList ( T a[ ], int n ) ; 
　　~LinkList ( ) ; 
　　int Length ( ) ;
　　T Get ( int i ) ; 
　　int Locate ( T x ) ;
　　void Insert ( int i, T x ) ;
　　T Delete ( int i ) ; 
　　void PrintList ( ) ; 
　　private: 
　　 Node<T>  *first; // 单链表的头指针  , <T>可以省略
}; 

• 头插法
  带头结点

template <class T>  
LinkList<T>:: LinkList(T a[ ], int n) {
   first=new Node<T>;
   first->next=NULL;  //初始化一个空链表
   Node<T> *s;
   for (int i=0; i<n; i++){ 
          s=new Node<T>; 
          s->data=a[i];  //为每个数组元素建立一个结点
          s->next=first->next;
          first->next=s;  //将结点s插入到头结点之后
 }
}

不带头结点

{
    first=NULL;
    for(int i=0;i<n;i++)    
    { 
         s=new node<T>;
         s->data=a[i];
         s->next=first;
         first=s;   
    }
}

• 尾插法
  带头结点

template <class T>  
LinkList<T>:: LinkList(T a[ ], int n) {
    Node<T> *r,*s;      //尾指针
    first=new Node<T>;   //生成头结点
    r=first;          //尾指针初始化
    for (int i=0; i<n; i++) { 
        s=new Node<T>; 
        s->data=a[i];  //为每个数组元素建立一个结点
        r->next=s; r=s;      //将结点s插入到终端结点之后
 }
    r->next=NULL;    //单链表建立完毕，将终端结点的指针域置空
 }

不带头结点

    node<T> *r;
    head=NULL;
    if（n<=0）return;
    s=new node<T>;
    s->data=a[0];
    s->next=head;
    head=s;   
    r=head;
    for(int i=1;i<n;i++)    
    { 
         s=new node<T>;
         s->data=a[i];
         r->next=s;
         r=s;   
    }

• 遍历算法

 template <class T>  
 LinkList<T>:: PrintList()
 {
     Node<T> *p;
     p=first->next;          
     while(p)
     {
         cout<<p->data;
         p=p->next;
     }
 }

• 查找算法
  按位置

template <class T>
T LinkList<T>::Get(int i) {   
   Node<T> *p; int j;
   p=first->next;  j=1;  //或p=first;  j=0;
   while (p && j<i) {
      p=p->next;       //工作指针p后移
  j++;
    }
   if (!p) throw "位置";
   else return p->data;
}

• 插入算法

template <class T>  
void LinkList<T>::Insert(int i, T x){  
   Node<T> *p; int j;
   p=first ; j=0;    //工作指针p初始化
   while (p && j<i-1)   
   {
     p=p->next;   //工作指针p后移
     j++;
   }
   if (!p) throw "位置";
    else { 
      Node<T> *s;
      s=new Node<T>; 
      s->data=x;  //向内存申请一个结点s，其数据域为x
      s->next=p->next;       //将结点s插入到结点p之后
      p->next=s; 
 }
 }

• 删除算法

template <class T>  
T LinkList<T>::Delete(int i){ 
  Node<T> *p; int j;
  p=first ; j=0;  //工作指针p初始化
  while (p && j<i-1)
  {  //查找第i-1个结点
    p=p->next; 
    j++;
  }
  if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在
    else {
        Node<T> *q; T x;
        q=p->next; x=q->data;  //暂存被删结点
        p->next=q->next;  //摘链
        delete q; 
        return x;
    }
}

• 析构函数

template <class T>
LinkList<T>:: ~LinkList()
{
   Node<T> *q;
   while (first)
   {
       q=first->next;
       delete first;
       first=q;
    }
}