双向链表解读

转载自：

http://blog.csdn.net/feixiaoxing/article/details/6849457

http://blog.sina.com.cn/s/blog_7d44748b01013fsf.html

双向链表，顾名思义，就是数据本身具备了左边和右边的双向指针。双向链表相比较单向链表，主要有下面几个特点：

    （1）在数据结构中具有双向指针

    （2）插入数据的时候需要考虑前后的方向的操作

    （3）同样，删除数据的是有也需要考虑前后方向的操作

网上很多对双向链表解释的文章都是用这个结构：

 

它们的连接情况是这样的：

 

相当的不直观，今天我要从详细的地址出发来解释双向链表的原理。

 

现定义一个结构体如下：

struct student

{char name;

struct student *next;

struct student *prior;

};

现在有5个人A,B,C,D,E.这五个人构成的链表如下：

 

虚线部分为地址值，这个是为了描述方便随便写的值，在创建上述的链表时其实不用关心地址值到底是多少，这些地址都会放到某个变量当中，只要对变量进行赋值传递就能实现链表的构建。这里完全是为了分析才这么写的。从图中很容易看出蓝色的箭头组成了一个单链表，红色的箭头又组成了一个单链表（逆向的）。

下面将分析链表的前插与删除的例子，理解了这两个功能，其他的功能都能自己分析出来了。

双链表的前插，下面这是代码和代码分析。

void InsertBefore(student *p,char x)
      {//在带头结点的双链表中，将值为x的新结点插入*p之前，设p≠NULL
        student *s=malloc(sizeof(student)); //申请一段内存空间，指针指向首地址0x0600
        s->name=x; //定义name为G
        s->prior=p->prior; // p->prior表示0x0500，将它赋给s->prior表示s->prior里面的值是0x0500，从而指向0x0500这个地址即q，如紫线
        s->next=p; //p是0x0700，将它赋给s->next，s->next中的值为0x0700，也即s->next指向了p，如绿色线
        p->prior->next=s; // p->prior 是0x0500，即指针q所指，所以p->prior->next相当于没插入s之前的0x0700，插入s后，将s的首地址即0x0600赋给这个位置，所以此时，由q 到p的蓝线断裂，这个蓝线目标变成了s，如黑线所示，此时q->next值为0x0600，图上没有改过来。
        p->prior=s; //同理，p->prior也指向了s，即p->prior中0x0500变成了0x0600（图上没有改过来），红线断裂。变成墨绿色线。至此前插完成。
       } 

 

 

下面再分析删除，删除比较简单，代码如下：

void DeleteNode(student *p)
      {//在带头结点的双链表中，删除结点*p，设*p为非终端结点
          p->prior->next=p->next;// 将p->next即0x0700送到q->next中，即0x0500被替换成了0x0700（图中没改过来），如紫线。
          p->next->prior=p->prior;// p->prior为0x0300送到了s->prior即原本是0x0500的地方（图中没改过来），如绿线。
          free(p);//将p内存释放，同时将之前的四根红蓝线全部断裂，至此完成删除任务。 

 

那么，一个非循环的双向链表操作应该是怎么样的呢？我们可以自己尝试一下：

    （1）定义双向链表的基本结构

[cpp] view plain copy

1. typedef struct _DOUBLE_LINK_NODE  
2. {  
3.     int data;  
4.     struct _DOUBLE_LINK_NODE* prev;  
5.     struct _DOUBLE_LINK_NODE* next;  
6. }DOUBLE_LINK_NODE;  

    （2）创建双向链表节点

[cpp] view plain copy

1. DOUBLE_LINK_NODE* create_double_link_node(int value)  
2. {  
3.     DOUBLE_LINK_NODE* pDLinkNode = NULL;  
4.     pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE));  
5.     assert(NULL != pDLinkNode);  
6.   
7.     memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE));  
8.     pDLinkNode->data = value;  
9.     return pDLinkNode;  
10. }  

    （3）删除双向链表

[cpp] view plain copy

1. void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode)  
2. {  
3.     DOUBLE_LINK_NODE* pNode;  
4.     if(NULL == *pDLinkNode)  
5.         return ;  
6.   
7.     pNode = *pDLinkNode;  
8.     *pDLinkNode = pNode->next;  
9.     free(pNode);  
10.     delete_all_double_link_node(pDLinkNode);  
11. }  

    （4）在双向链表中查找数据

[cpp] view plain copy

1. DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int data)  
2. {  
3.     DOUBLE_LINK_NODE* pNode = NULL;  
4.     if(NULL == pDLinkNode)  
5.         return NULL;  
6.   
7.     pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
8.     while(NULL != pNode){  
9.         if(data == pNode->data)  
10.             return pNode;  
11.         pNode = pNode ->next;  
12.     }  
13.       
14.     return NULL;  
15. }  

    （5）双向链表中插入数据

[cpp] view plain copy

1. STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)  
2. {  
3.     DOUBLE_LINK_NODE* pNode;  
4.     DOUBLE_LINK_NODE* pIndex;  
5.   
6.     if(NULL == ppDLinkNode)  
7.         return FALSE;  
8.   
9.     if(NULL == *ppDLinkNode){  
10.         pNode = create_double_link_node(data);  
11.         assert(NULL != pNode);  
12.         *ppDLinkNode = pNode;  
13.         (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;  
14.         return TRUE;  
15.     }  
16.   
17.     if(NULL != find_data_in_double_link(*ppDLinkNode, data))  
18.         return FALSE;  
19.   
20.     pNode = create_double_link_node(data);  
21.     assert(NULL != pNode);  
22.   
23.     pIndex = *ppDLinkNode;  
24.     while(NULL != pIndex->next)  
25.         pIndex = pIndex->next;  
26.   
27.     pNode->prev = pIndex;  
28.     pNode->next = pIndex->next;  
29.     pIndex->next = pNode;  
30.     return TRUE;  
31. }  

    （6）双向链表中删除数据

[cpp] view plain copy

1. STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)  
2. {  
3.     DOUBLE_LINK_NODE* pNode;  
4.     if(NULL == ppDLinkNode || NULL == *ppDLinkNode)  
5.         return FALSE;  
6.   
7.     pNode = find_data_in_double_link(*ppDLinkNode, data);  
8.     if(NULL == pNode)  
9.         return FALSE;  
10.   
11.     if(pNode == *ppDLinkNode){  
12.         if(NULL == (*ppDLinkNode)->next){  
13.             *ppDLinkNode = NULL;  
14.         }else{  
15.             *ppDLinkNode = pNode->next;  
16.             (*ppDLinkNode)->prev = NULL;  
17.         }  
18.   
19.     }else{  
20.         if(pNode->next)  
21.             pNode->next->prev = pNode->prev;  
22.         pNode->prev->next = pNode->next;  
23.     }  
24.   
25.     free(pNode);  
26.     return TRUE;  
27. }  

    （7）统计双向链表中数据的个数

[cpp] view plain copy

1. int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode)  
2. {  
3.     int count = 0;  
4.     DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
5.   
6.     while(NULL != pNode){  
7.         count ++;  
8.         pNode = pNode->next;  
9.     }  
10.     return count;  
11. }  

    （8）打印双向链表中数据

[cpp] view plain copy

1. void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode)  
2. {  
3.     DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
4.   
5.     while(NULL != pNode){  
6.         printf("%d\n", pNode->data);  
7.         pNode = pNode ->next;  
8.     }  
9. }