数据结构（三） 单链表

一、学后感:单链表不如顺序表简单，头插尾插应用广泛，链表使用更广泛；难度有些大。。。
二、笔记：

结点之间可以连续，也可以不连续存储;结点的逻辑顺序与物理顺序可以不一致;表可扩充。

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->nex;
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>:: PrintList(){
Node<T> *p;
  p=first->next;          
while(p)
 {
  cout<<p->data;
   p=p->next;
  } }

按位置查找
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 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;
}

插入算法
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 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;
}

不带头结点的
头插法：

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

尾插法

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;   
}

插入

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;      
  } }