数据结构：单链表，循环链表，双项链表的实现

单链表：

单链表是一种链式存取的数据结构，用一组地址任意的 存储单元 存放线性表中的 数据元素 。链表中的数据是以结点来表示的，每个结点的构成： 元素(数据元素的映象) + 指针(指示后继元素存储位置)， 元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

①：链表通过每个结点的链域（指针域）将线性表的n个结点按其逻辑顺序链接在一起的。

②：每个结点只有一个链域的链表称为单链表（Single Linked List）。

类型描述如下：
typedef struct Node
{
 int data;//保存数据
 struct Node *next;//保存下一个结点的地址
}Node,*List;

//typedef struct Node * List;

这里我们为方便起见建立一个带头结点的单链表，头结点的数据域不存放数据。

单链表的实现：

//初始化
void InitList(List plist)
{
 assert(plist != NULL);
 if(plist == NULL)
 {
  return ;
 }
 plist->next = NULL;//链表的尾结点指针域为NULL，初始化无需考虑数据域
}

//头插
bool Insert_head(List plist,int val)//O(1)
{
 Node *p = (Node *)malloc(sizeof(Node));
 p->data = val;
 p->next = plist->next;
 plist->next = p;
return true；
}

//尾插
bool Insert_tail(List plist,int val)//O(n)
{
 Node *p = (Node *)malloc(sizeof(Node));
 p->data = val;
 Node *q;
 for(q=plist;q->next!=NULL;q=q->next) ;//找尾巴
 //将p插入在q后面
 p->next = q->next;//或者（p->next =  NULL；）
 q->next = p;
 return true;
}

//查找
Node *Srearch(List plist,int key)
{
 for(Node *p=plist->next;p!=NULL;p=p->next)
 {
  if(p->data == key)
  {
   return p;
  }
 }
 return NULL;
}


//删除
bool Delete(List plist,int key)
{
 Node *p;
 for(p=plist;p->next!=NULL;p=p->next) 
 {
  if(p->next->data == key)
  {
   Node *q = p->next;//记录需要删除的节点
   p->next = q->next;
   free(q);  
   return true;
  }
 }
 return false;
}

//摧毁（清除可直接调用摧毁）
void Destroy(List plist)
{
 Node *p;
 while(plist->next != NULL)
 {
  p = plist->next;
  plist->next = p->next;
  free(p);
 }
}

//逆置（非常重要！！！）
void Reverse(List plist)
{
 if(plist==NULL || plist->next==NULL || plist->next->next==NULL)
 {
  return ;
 }
 //下面的时间复杂度为O(n),并且最好，利用头插的思想
 Node *p = plist->next;
 Node *q;
 plist->next = NULL;
 while(p != NULL)
 {
  q = p->next;
  p->next = plist->next;//将节点p头插到链表中
  plist->next = p;
  p = q;
 }

循环链表：

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

类型描述：
typedef struct CNode
{
 int data;
 struct CNode *next;
}CNode,*CList;  //与单链表没区别

//链表初始化
void InitList(CList plist)
{
 assert(plist != NULL);
 if(plist==NULL)
 {
  return ;
 }
 plist->next = plist;//plist->next = NULL;（单链表与循环链表的区别）
}

//头插（与单链表无区别）
bool Insert_head(CList plist,int val)
{
 CNode *p = (CNode *)malloc(sizeof(CNode));
 p->data = val;
 p->next = plist->next;
 plist->next = p;
 return true;
}

//尾插
bool Insert_tail(CList plist,int val)
{
 CNode *p = (CNode *)malloc(sizeof(CNode ));
 p->data = val;
 CNode *q;
 for(q=plist;q->next!=plist;q=q->next) ;
 //将p插入在q的后面
 p->next = q->next;//p->next = plist;
 q->next = p;
 return true;
}


//查找
CNode *Srearch(CList plist,int key)
{
 for(CNode *p=plist->next;p!=plist;p=p->next)
 {
  if(p->data == key)
  {
   return p;
  }
 }
 return NULL;
}

（内部函数，找到前一个）
static CNode *SearchPri(CList plist,int key)
{
 for(CNode *p=plist;p->next!=plist;p=p->next)
 {
  if(p->next->data == key)
  {
   return p;
  }
 }
 return NULL;
}

//删除
bool Delete(CList plist,int key)
{
 CNode *p = SearchPri(plist,key);  （找到前一个）
 if(p == NULL)
 {
  return false;
 }
 CNode *q = p->next;
 p->next = q->next;
 free(q);
 return true;
}

双向链表：

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

类型描述：
typedef struct DNode
{
   int data;
   struct DNode *next;//后继指针
    struct DNode *prio;//前驱指针
}DNode,*DList;

//链表初始化
void InitList(DList plist)
{
 assert(plist != NULL);
 if(plist == NULL)
 {
  return ;
 }
 plist->next = NULL;
 plist->prio = NULL;
}

//头插
bool Insert_head(DList plist,int val)
{
 DNode *p = (DNode *)malloc(sizeof(DNode));
 p->data = val;
 p->next = plist->next;//1
 plist->next = p;
 p->prio = plist;
 if(p->next != NULL)
 {
  p->next->prio = p;
 }
 return true;
}


//尾插
bool Insert_tail(DList plist,int val)
{
 DNode *q = (DNode *)malloc(sizeof(DNode));
 q->data = val;
 DNode *p;
 for(p=plist;p->next!=NULL;p=p->next) ;
 //将q插入在p的后面
 q->next = p->next;//q->next = NULL;
 p->next = q;
 q->prio = p;
 return true;
}


//查找
DNode *Search(DList plist,int key)
{
 for(DNode *p=plist->next;p!=NULL;p=p->next)
 {
  if(p->data == key)
  {
   return p;
  }
 }
 return NULL;
}

//删除
bool Delete(DList plist,int key)
{
 DNode *p = Search(plist,key);
 if(p == NULL)
 {
  return false;
 }
 p->prio->next = p->next;
 if(p->next != NULL)
 {
  p->next->prio = p->prio;
 }
 free(p);
 return true;
}

//摧毁
void Destroy(DList plist)
{
 DNode *p;
 while(plist->next != NULL)
 {
  p = plist->next;
  plist->next = p->next;
  free(p);
 }
}

分享：