数据结构笔记：链表

链式存储结点左边存数据元素，右边存下一个结点的地址。

用结构类型来描述单链表的结点：

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 ( ) ; 
　　
    函数

　　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) 
{
    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;          //r为尾指针
    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(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;   
    }

}

遍历单链表：

template <class T>  
LinkList<T>:: PrintList()
{
    Node<T> *p;
	p=first->next;    //p指向第一个结点        
     while(p)
	{
		cout<<p->data;    //输出p所在结点的值
            p=p->next;           //p指向下一个结点
	}
 }

单链表按位置查找：

template <class T>
T LinkList<T>::Get(int i) {   
	  Node<T> *p; int j;     //p为查找的指针
	  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){     //i为要插入的位置
   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;    //q指向要删除结点的下一个
       delete first;
       first=q;
    }
}

循环链表：将链表的头尾结点链接起来

构建空表：

template <class T>
CycleLinkList<T>:: CycleLinkList( )
{
         first=new Node<T>; first->next=first;   //first的指针指向first  形成循环
}

尾插法构建循环链表只需将尾插法构建单链表最后尾指针指向first

头插法构建循环链表只需将尾插法构建空链表时的初始化单链表的first->next=NULL改为指向first

双链表：

双链表的结点由指向左边结点的左指针、数据、指向右边结点的右指针构成。

template <class T> struct  DNode

{     

T  data;   

 DNode<T> *llink;     

DNode <T>*rlink;

};

双链表插入结点时先从左往右再从右往左或者先从右往左再从左往右。

删除p：

         p->llink->rlink=p->rlink;

         p->rlink->llink=p->rlink;  

         delete(p);

双链表构建空表：

template <class T> 
DoubleLink <T>::DoubleLink(){
		head=new Node<T>;
		head->rlink=NULL;
		head->llink=NULL;
	}

双链表头插：

template <class T>
void DoubleLink<T>::Append(T data){
	      Node<T> *s;
     	s=new Node<T>;
	       s->data=data;
		s->rlink=head->rlink;
		head->rlink=s;
		s->llink=head;
		if (s->rlink)
			s->rlink->llink=s;
		return;
}

双链表遍历：

template <class T>
void DoubleLink<T>::Display(){
	Node <T> *p;
	p=head->rlink;
	while(p)	{
		cout<<p->data<<"   ";
		p=p->rlink;
	}
	cout<<endl;
	return;
}

双链表析构：

template <class T>
DoubleLink<T>::~DoubleLink(){
	Node<T>  *p,*q;
	p=head;
	while(p)
	{
		q=p->rlink;
		delete p;
		p=q;
		
	}
}