[学习笔记]双向链表

文章首发:http://pjf.name/post-113.html

本文基于"姓名标识-非商业性-相同方式分享 4.0国际"协议创作或转载,转载原创文章请注明来源于疯子的自留地,否则请勿转载或再转载,谢谢合作:)

      什么是双向链表呢?其实就是在单链表的基础上添加了小功能,即每个结点不仅有后驱指针域,同时增加了前驱指针域,这样查找数据就更加方便了,比如说当前结点是头结点,如果是要指向尾结点的话就只需要我们把头结点的前驱指针域指向尾结点,这样就可以直接指向尾结点,时间复杂度就为O(1),不过也带来了弊端,即增加了空间的消耗,不过有时候空间换时间还是值得的不是.

      同时我们依旧可以使用头结点,跟循环单链表不同,因为结点多了一个前驱指针域,所以使用头指针时增删头,尾结点是可行的,当然,尾指针也一样可以使用,原因相同

双向链表的数据结构为:

1 typedef struct Node{
2     struct Node *Prior;
3     char Data;
4     struct Node *Next;
5 }Node;
6
7 typedef struct Node *List;

基本操作也是跟一般链表一样的:

1.整表创建:

01 BOOL CreateNewDoubleLinkList(List *L,int Length)
02 {
03     int temp;
04     char Chart='a';
05     List EndNode,NewEndNode;
06
07     *L=(List)malloc(sizeof(Node));//为头指针分配内存
08     if(!(*L))
09         return false;
10     EndNode=*L;//先让尾结点指向头指针
11     for(temp=0;temp
12     {
13         NewEndNode=(List)malloc(sizeof(Node));//为新的尾结点分配内存
14         if(!NewEndNode)
15             return false;
16         NewEndNode->Data=Chart;//为新的尾结点赋值
17         NewEndNode->Prior=EndNode;//新的尾结点的前驱指针指向原来的尾结点
18         EndNode->Next=NewEndNode;//原来的尾结点的后驱指针指向新的尾结点
19         EndNode=NewEndNode;//让原来的尾结点指向新的尾结点
20     }
21     EndNode->Next=(*L)->Next;//尾结点的后驱指针域指向头结点
22     (*L)->Next->Prior=EndNode;//头结点的前驱指针域指向尾结点
23     (*L)->Prior=EndNode;//头指针的前驱指针域别浪费了,让他指向尾结点吧:)
24     (*L)->Data=temp;//头指针的数据域保存链表的长度
25
26     return true;
27 }

2.整表删除:

01 BOOL EmptyDoubleLinkList(List *L)
02 {
03     List DeletePreNode,DeleteNode;
04     int temp;
05
06     if((int)(*L)->Data==0)//当链表为空时,返回错误
07         return false;
08
09     DeletePreNode=(*L)->Prior;//先让与删除的前一个结点指向头指针,为何这样具体参见我关于循环链表的笔记:)
10     for(temp=1;temp<(int)(*L)->Data;temp++)//清空链表
11     {
12         DeleteNode=DeletePreNode->Next;//保存要删除结点的地址
13         DeleteNode->Next->Prior=DeletePreNode;//把要删除的结点的下一个结点的前驱指针域指向欲删除结点的前一个结点
14         DeletePreNode->Next=DeleteNode->Next;//把欲删除的前一个结点的后驱指针域指向要删除的节点的下一个结点地址
15         free(DeleteNode);//释放与删除的结点内存
16         DeletePreNode=DeletePreNode->Next;//欲删除的结点地址后移一位
17     }
18     free(DeletePreNode);//释放尾结点的内存,这里很容易出错,可以当上面的for循环再做左后一个循环时就只剩下两个结点,然后最后释放了第二个结点,即只剩下一个结点,这个结点的前驱和后驱指针域都是指向它自己的,所以当退出循环时只剩下它自己,也就是我们链表中的最后一个数据(其实是最初链表的倒数第二个结点),因此我们在这里释放它的内存
19     (*L)->Prior=(*L)->Next=NULL;//头指针的前驱和后驱指针域指向null
20     (*L)->Data=0;//链表长度改为0
21
22     return true;
23 }

3.整表遍历:

01 BOOL BrowseDoubleLinkList(List L)
02 {
03     List CurrentNode;
04     int count=1;
05
06     if(0==(int)L->Data)
07         return false;
08
09     CurrentNode=L->Next;//当前结点指向头指针;
10     while(count<=L->Data)//输出链表数据
11     {
12         printf("%3c",CurrentNode->Data);//输出当前结点数据
13         if(count%6==0)
14             printf("\n");
15         CurrentNode=CurrentNode->Next;//当前结点后移一位
16         count++;
17     }
18
19     return true;
20 }

4.插入数据:

01 BOOL InsertDoubleLinkList(List *L,int InsertPostion,char InsertData)
02 {
03     int temp;
04     List CurrentNode,InsertNode;
05
06     if(InsertPostion<1)//如果插入位置小于1,则默认新的插入位置在第一个
07         InsertPostion=1;
08     if(InsertPostion>(int)(*L)->Data+1)//如果插入位置大于链表长度加1,则默认新的插入位置为表尾
09         InsertPostion=(int)(*L)->Data+1;
10
11     CurrentNode=*L;//当前结点指向头指针
12
13     for(temp=0;temp//把当前结点指向要插入的位置
14     {
15         CurrentNode=CurrentNode->Next;
16     }
17
18     InsertNode=(List)malloc(sizeof(Node));//为要插入的结点分配内存
19     if(!InsertNode)
20         return false;
21     InsertNode->Data=InsertData;//把数据插入要插入的结点处
22     InsertNode->Next=CurrentNode;//当要插入的结点的后驱指针域指向要当前结点
23     InsertNode->Prior=CurrentNode->Prior;//把当前结点的上一个结点指向要插入结点的前驱指针域
24     CurrentNode->Prior->Next=InsertNode;//把要插入的结点指向当前结点的上一个结点的后驱指针域
25     CurrentNode->Prior=InsertNode;
26
27     if(1==temp)//如果插入的位置为表头,则更新头指针的后驱指针域
28         (*L)->Next=InsertNode;
29     if((temp-1)==(*L)->Data)//如果插入的是表尾,则更新头指针的前驱指针域
30         (*L)->Prior=InsertNode;
31
32     (*L)->Data++;
33
34     return true;
35 }

5.删除数据:

01 BOOL DeleteDataDoubleLinkList(List *L,int DeletePosithion,char *DeleteData)
02 {
03     List DeleteNode;
04     int temp;
05
06     if(0==(int)(*L)->Data||DeletePosithion>(int)(*L)->Data||DeletePosithion<1)//链表为空时或删除位置不存在时,返回错误
07         return false;
08
09     DeleteNode=*L;//首先指向头指针
10     for(temp=0;temp//把当前指针移动到欲删除的结点处
11         DeleteNode=DeleteNode->Next;
12     DeleteNode->Prior->Next=DeleteNode->Next;//欲删除的前一个结点的后驱指针域指向欲删除结点的后一个结点
13     DeleteNode->Next->Prior=DeleteNode->Prior;//欲删除的后一个结点前驱指针域指向欲删除的前一个结点
14
15     if(1==DeletePosithion)//如果删除的是头结点,则更新头指针的后驱指针域
16         (*L)->Next=DeleteNode->Next;
17     if(DeletePosithion==(int)(*L)->Data)//如果删除的是尾结点,则更新头指针的前驱指针域
18         (*L)->Prior=DeleteNode->Prior;
19
20     *DeleteData=DeleteNode->Data;//输出删除的数据
21     free(DeleteNode);//释放欲删除结点的内存
22
23     (*L)->Data--;//链表的长度减一
24
25     return true;
26 }

同样写一个小程序跑一下:

01 #define true 1
02 #define false 0
03 #define BOOL int
04
05 #include
06 #include
07
08 int main(void)
09 {
10     List DL;
11     char Output;
12
13     if(false==CreateNewDoubleLinkList(&DL,20))
14         return false;
15     printf("成功建立链表!\n");
16     printf("当前链表数据为:\n");
17     BrowseDoubleLinkList(DL);
18     printf("\n当前链表长度为:%d\n",(int)DL->Data);
19     printf("在第12个位置插入数据'~'...\n");
20     if(false==InsertDoubleLinkList(&DL,12,'~'))
21         return false;
22     printf("插入数据成功!\n");
23     printf("当前链表数据为:\n");
24     BrowseDoubleLinkList(DL);
25     printf("\n当前链表长度为:%d\n",(int)DL->Data);
26     printf("删除第5个数据...\n");
27     if(false==DeleteDataDoubleLinkList(&DL,5,&Output))
28         return false;
29     printf("成功删除第5个数据,删除的值为%c\n",Output);
30     printf("当前链表数据长度为:%d,新的链表如下:\n",(int)DL->Data);
31     BrowseDoubleLinkList(DL);
32     printf("\n清空数据表...\n");
33     if(false==EmptyDoubleLinkList(&DL))
34         return false;
35     printf("\n已清空链表!\n当前链表长度为:%d\n",(int)DL->Data);
36     getchar();
37
38     return 0;
39 }

运行效果图: