线性表->链式存储->双向链表

文字描述

　　之前的链表(单链表、循环链表)的链式存储结构中只有一个指示直接后继的指针域。由此，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前驱，则需从表头指针出发。即单链表中，NextElem的执行时间为1，而PriorElem的执行时间为n。为了克服单链表这种缺点，可利用双向链表。

　　在双向链表中，每个节点有两个指针域，一个指向其直接后继，一个指向其直接前驱。

示意图

算法分析

插入、删除、查找、求后继等同单链表。但是求前驱不一样，其时间复杂度为1。

代码实现

 //
 // Created by lady on 19-1-31.
 //

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>

 //线性表的双向循环链表存储结构
 typedef struct ElemType{
     char data[];
 }ElemType;
 typedef struct DuLNode{
     ElemType e;
     struct DuLNode *prior;
     struct DuLNode *next;
 }DuLNode, *DuLinkList;

 //构造一个空的双向循环链表
 static int InitList_DuL(DuLinkList *L)
 {
     (*L) = (DuLinkList)malloc(sizeof(DuLNode));
     (*L)->prior = (*L);
     (*L)->next = (*L);
     memset((*L)->e.data, , sizeof((*L)->e.data));
     return ;
 }

 //销毁L
 static int Destory_DuL(DuLinkList *L)
 {
     DuLNode *p = NULL;
     DuLNode *q = NULL;
     p = (*L)->next;
     while(p){
         q = p;
         p = p->next;
         free(q);
         if(p == (*L))
             break;
     }
     free(*L);
     (*L) = NULL;
     return ;
 }

 //返回双向链表L中的第i个位置的元素
 static DuLNode *GetElemP_DuL(DuLinkList *L, int i)
 {
     if(L == NULL){
         return NULL;
     }
     DuLNode *p = (*L)->next;
     int index = ;
     while(index<i && p){
         index += ;
         p = p->next;
     }
     if(index == i && p){
         return p;
     }else{
         return NULL;
     }
 }

 //在L的指定位置i的元素前面插入元素e
 static int ListInsert_DuL(DuLinkList *L, int i, ElemType e)
 {
     DuLNode *p = NULL;
     DuLNode *new = NULL;
     if((p=GetElemP_DuL(L, i)) == NULL){
         return -;
     }
     if((new = (DuLNode*)malloc(sizeof(DuLNode))) == NULL){
         return -;
     }
     new->e = e;
     new->prior = p->prior;
     p->prior->next = new;
     new->next = p;
     p->prior = new;
     return ;
 }

 //删除L中的第loc个数据元素，并将被删元素的值存放在e中
 static int ListDelete_DuL(DuLinkList *L, int i, ElemType *e)
 {
     DuLNode *p = NULL;
     if((p=GetElemP_DuL(L, i)) == NULL){
         return -;
     }
     (*e) = p->e;
     p->prior->next = p->next;
     p->next->prior = p->prior;
     free(p);
     return ;
 }

 //依次对L的每个数据元素调用函数fun
 static int listTraverse_DuL(DuLinkList *L, int (*fun)(ElemType,int), char note[])
 {
     printf("遍历双向循环链表%s:", note);
     DuLNode *p = NULL;
     p = (*L)->next;
     int i = ;
     while(p){
         fun(p->e, i);
         i+=;
         p = p->next;
         if(p == (*L))
             break;
     }
     printf("\n");
     return ;
 }

 static int print(ElemType e, int loc)
 {
     printf("%3d=%-10s", loc, e.data);
 }

 //创建一个长度为n的双向链表
 static int CreateList_DuL(DuLinkList *L, int n, char note[])
 {
     printf("创建一个长度为%d的双向循环链表%s!\n", n, note);
     InitList_DuL(L);
     ElemType e;
     int i = ;
     for(i=; i<n; i++){
         printf("输入第%d个元素:", i+);
         scanf("%s[^\\n]", e.data);
         ListInsert_DuL(L, i+, e);
     }
     return ;
 }

 int main(int argc, char *argv[])
 {
     ElemType e;
     DuLinkList L;
     int location=;

     CreateList_DuL(&L, , "L");

     listTraverse_DuL(&L, print, "L");

     printf("输入插入元素的位置:");
     scanf("%d", &location);
     printf("输入插入元素的数据:");
     scanf("%s[^\\n]", e.data);
     ListInsert_DuL(&L, location, e);
     listTraverse_DuL(&L, print, "L");

     printf("输入删除元素的位置:");
     scanf("%d", &location);
     ListDelete_DuL(&L, location, &e);

     printf("位于%d的元素%s已经从双向循环链表中被删除！\n", location, e.data);
     listTraverse_DuL(&L, print, "L");

     Destory_DuL(&L);
     printf("双向链表已经被销毁!\n");
     return ;
 }

双向链表

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
创建一个长度为5的双向循环链表L!
输入第1个元素:c
输入第2个元素:b
输入第3个元素:e
输入第4个元素:g
输入第5个元素:f
遍历双向循环链表L:  1=c           2=b           3=e           4=g           5=f
输入插入元素的位置:3
输入插入元素的数据:test
遍历双向循环链表L:  1=c           2=b           3=test        4=e           5=g           6=f
输入删除元素的位置:4
位于4的元素e已经从双向循环链表中被删除！
遍历双向循环链表L:  1=c           2=b           3=test        4=g           5=f
双向链表已经被销毁!

Process finished with exit code 0