线性表——单链表

• 链表结点数据类型的定义
  在C++中，可以用结构类型来描述单链表的结点 ，由于结点的元素类型不确定，所以采用C++的模板机制。

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 ) ; //有参构造函数，建立有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;
	}
}

②尾插法：

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;      //插入到终端结点之后
	}
    r->next=NULL;    //单链表建立完毕，将终端结点的指针域置空
 }

• 析构函数

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

• 单链表的长度

template <class T>
int LinkList<T>::length()
{
	p=first->next;int count=0;
	while(p!=NULL)
	{
		p=p->next;
		count++;
	}
	return count;
}

• 按位查找
  查找算法：
  1、工作指针P初始化，计数器初始化
  2、执行下列操作，直到p为空或指向第i个节点
  2.1 工作指针后移
  2.2 计数器增1
  3、若p为空，则第i个元素不存在，抛出位置异常；否则查找成功，返回节点p的数据元素

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

• 按值查找

template <class T>
T LinkList<T>::Locate(T x) {   
	  Node<T> *p; int count;
	  p=first->next; count=1;  
	  while (p) {
	  	if(p->data==x)return count;
    		p=p->next;       //工作指针p后移
			count++;
  	 }
	 return 0;
}

• 插入操作
  插入算法：
  1、工作指针p初始化，计数器初始化
  2、查找第i-1个节点，并使工作指针p指向该节点
  3、若查找不成功（P==NULL），说明位置错误，抛出位置异常，否则
  3.1 生成一个元素值为x的新节点s
  3.2 将s插入到p之后

template <class T>  
void LinkList<T>::Insert(int i, T x){  
   Node<T> *p; int count;
   p=first ; count=0;    //工作指针p初始化
   while (p && count<i-1)   {
     p=p->next;   //工作指针p后移
     count++;
   }
   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;	
	}
 }

• 删除操作
  删除算法：
  1、工作指针p初始化；累加器count初始化；
  2、查找第i-1个结点并使工作指针p指向该结点；
  3、若p不存在或p的后继结点不存在，则抛出位置异常；
  否则
  3.1 暂存被删结点和被删元素值
  3.2 摘链，将结点p的后继结点从链表上摘下
  3.3 释放被删结点
  3.4 返回被删元素值

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>:: PrintList()
{
    Node<T> *p;
	p=first->next;          
    while(p)  //等同于while(p!=NULL)
	{
		cout<<p->data;
        p=p->next;
	}
 }

不带头结点的操作
1.头插法：

template <class T>  
LinkList<T>:: LinkList(T a[ ], int n) {
    first=NULL;
   for (int i=0; i<n; i++){ 
          s=new Node<T>; 
          s->data=a[i];  //为每个数组元素建立一个结点
          s->next=first;
          first=s;
	}
}

2.尾插法：

template <class T>  
LinkList<T>:: LinkList(T a[ ], int n) 
{
 	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;   
    }

3.插入操作

template <class T>  
void LinkList<T>::Insert(int i, T x){  
   Node<T> *p; int j;
   if（i<=0） throw “位置非法”；
   if （i==1 ）{ s=new Node<T>;s->next=head;head=s;return}
   p=first ; j=1;    //工作指针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;	
	}
 }