线性表的链式存储结构-双向链表及双向循环链表

最新推荐文章于 2023-05-01 21:33:23 发布
最新推荐文章于 2023-05-01 21:33:23 发布
阅读量3.7k 收藏 13
点赞数 3
分类专栏： 数据结构与算法笔记 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoyongming925/article/details/105663003
版权

目录


上一篇文章我们介绍了 单链表及循环链表，现在我们了解一下双向链表及双向循环链表。

1. 双向链表

单链表中，每个结点有一个指向其直接后继结点的指针，整个单链表只能沿着一个方向操作，那么双向链表，顾名思义，在它的结点中，不仅包含直接后继结点的地址指针，还包含它的直接前驱结点地址指针。
结点定义：

#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

//定义结点
typedef struct Node{
    ElemType data;
    struct Node *prior;
    struct Node *next;
}Node;

typedef struct Node * LinkList;

结点结构如下：
在这里插入图片描述
了解了结点结构后，我们看一下非空链表的结构图：
带头结点：
在这里插入图片描述
不带头结点：
在这里插入图片描述

1.1 双向链表创建

双向链表的创建，我们默认创建带头结点的链表。
思路：

  1. 开辟空间，创建头结点，并且判断是否创建成功。
  2. 将头结点前驱指针设置为NULL，后继指针设置为NULL。
  3. 通过循环依次创建结点，并追加到链表末尾。
  4. 返回成功。

代码实现如下：

//创建双向链接
Status createLinkList(LinkList *L){
    //*L 指向头结点
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    (*L)->prior = NULL;
    (*L)->next = NULL;
    (*L)->data = -1;
    
    //新增数据
    LinkList p = *L;
    for(int i=0; i < 10;i++){
        //1.创建1个临时的结点，并设置初始值。
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->prior = NULL;
        temp->next = NULL;
        temp->data = i;
        
        //2.为新增的结点建立双向链表关系
        //temp 是p的后继
        p->next = temp;
        //temp 的前驱是p
        temp->prior = p;
        //p要记录最后的结点的位置,方便下一次插入
        p = p->next;
    }
    return OK;
}

1.2 双向链表插入结点

思路：

  1. 创建新结点temp，并进行初始化。
  2. 遍历查找插入位置结点的前驱结点位置。
  3. 如果插入的位置大于链表的总长度，返回ERROR。
  4. 判断是否插入在尾部，如果是，只需修改尾部结点与插入结点的关系。
  5. 如果不是插在尾部，则需修改插入结点与其前驱结点和后继结点的关系。
  6. 返回OK。
    在这里插入图片描述

代码实现如下：

//双向链表插入结点
Status ListInsert(LinkList *L, int i, ElemType data){
    //1. 插入的位置不合法 为0或者为负数
    if(i < 1) return ERROR;
    
    //2. 新建结点
    LinkList temp = (LinkList)malloc(sizeof(Node));
    temp->data = data;
    temp->prior = NULL;
    temp->next = NULL;
    
    //3.将p指向头结点!
    LinkList p = *L;
    
    //4. 找到插入位置i直接的结点
    for(int j = 1; j < i && p;j++) 
        p = p->next;
    
    //5. 如果插入的位置超过链表本身的长度
    if(p == NULL){
        return  ERROR;
    }
    
    //6. 判断插入位置是否为链表尾部;
    if (p->next == NULL) {
        p->next = temp;
        temp->prior = p;
    }else
    {
        //1 将p->next 结点的前驱prior = temp
        p->next->prior = temp;
        //2 将temp->next 指向原来的p->next
        temp->next = p->next;
        //3 p->next 更新成新创建的temp
        p->next = temp;
        //4 新创建的temp前驱 = p
        temp->prior = p;
    }
    return  OK;
}

1.3 双向链表删除指定结点

思路：

  1. 遍历查找删除位置结点的前驱结点位置，创建结点指针p指向该前驱结点。。
  2. 如果插入的位置小于1或者大于链表的总长度，返回ERROR。
  3. 创建结点指针delTemp指向待删除结点，修改结点p的next指向delTemp的next。
  4. 如果待删除结点delTemp有后继结点，那么修改其后继结点的prior指向p。
  5. 释放delTemp结点。
  6. 返回OK。
    在这里插入图片描述
    代码实现如下：
//删除双向链表指定位置上的结点
Status ListDelete(LinkList *L, int i, ElemType *e){
    int k = 1;
    LinkList p = (*L);
    //1.判断双向链表是否为空,如果为空则返回ERROR;
    if (*L == NULL) {
        return ERROR;
    }
    //2. 将指针p移动到删除元素位置前一个结点。
    while (k < i && p != NULL) {
        p = p->next;
        k++;
    }
    //3.处理前后边界条件，如果k>i 或者 p == NULL 则返回ERROR
    if (k>i || p == NULL) {
        return  ERROR;
    }
    //4.创建临时指针delTemp指向要删除的结点,并将要删除的结点的data赋值给*e,带回到main函数
    LinkList delTemp = p->next;
    *e = delTemp->data;
    //5. p->next等于要删除的结点的下一个结点
    p->next = delTemp->next;
    //6. 如果删除结点的下一个结点不为空,则将将要删除的下一个结点的前驱指针赋值p;
    if (delTemp->next != NULL) {
        delTemp->next->prior = p;
    }
    //7.删除delTemp结点
    free(delTemp);
    return OK;
}

1.4 双向链表删除指定元素

思路：

  1. 创建结点指针p，并指向头结点。
  2. 遍历双向链表，查找与指定值相等的结点p，即待删除结点p。
  3. 若待删除结点p存在，修改结点p的前驱结点的后继指针，若p有后继结点，修改结点p的后继结点的前驱指针。
  4. 返回OK。

代码实现如下：

//删除双向链表指定的元素
Status LinkListDeletVAL(LinkList *L, int data){
    //1.判断双向链表是否为空,如果为空则返回ERROR;
    if (*L == NULL) {
        return ERROR;
    }
    LinkList p = *L;
    //2.遍历双向链表
    while (p) {
        //2.判断当前结点的数据域和data是否相等,若相等则删除该结点
        if (p->data == data) {
            
            //修改被删除结点的前驱结点的后继指针
            p->prior->next = p->next;
            //修改被删除结点的后继结点的前驱指针
            if(p->next != NULL){
                p->next->prior = p->prior;
            }
            //释放被删除结点p
            free(p);
            //退出循环
            break;
        }
        //没有找到该结点,则继续移动指针p
        p = p->next;
    }
    return OK;
}

1.5 双向链表查找元素位置

思路：

  1. 创建结点指针p，并指向首元结点，创建索引i，并设置为1.
  2. 遍历双向链表，查找与指定指相当的结点p。
  3. 如果找到，则返回索引i。
  4. 如果未找到，返回-1。

代码实现如下：

//在双向链表中查找元素位置
int selectElem(LinkList L,ElemType elem){
    LinkList p = L->next;
    int i = 1;
    while (p) {
        if (p->data == elem) {
            return i;
        }
        i++;
        p = p->next;
    }
    return  -1;
}

1.6 双向链表更新结点数据

思路：

  1. 创建结点指针p，并指向首元结点。
  2. 遍历双向链表，查找待更新结点p。
  3. 重新赋值p->next。
  4. 返回OK。

代码实现如下：

Status replaceLinkList(LinkList *L,int index,ElemType newElem){
    if (index < 1) {
        return ERROR;
    }
    LinkList p = (*L)->next;
    for (int i = 1; i < index && p->next != NULL; i++) {
        p = p->next;
    }
    p->data = newElem;
    return OK;
}

1.7 双向链表遍历

思路：

  1. 创建结点指针temp，并指向首元结点。
  2. 若temp为NULL，则链表为空，直接return。
  3. 循环遍历temp，若temp不为空，输出temp结点值，若temp为空，链表已经遍历到结尾，退出循环。

代码实现如下：

void display(LinkList L){
    LinkList temp = L->next;
    if(temp == NULL){
        printf("打印的双向链表为空!\n");
        return;
    }
    while (temp) {
        printf("%d  ",temp->data);
        temp = temp->next;
    }
    printf("\n");
}

2. 双向循环链表

上面了解了双向链表，那么双向循环链表，顾名思义，就是就是将双向链表尾部结点和头结点连接起来，如下图：
空双向循环链表：
在这里插入图片描述
非空双向循环链表：
在这里插入图片描述

2.1 双向循环链表创建

思路：

  1. 开辟空间，创建头结点，并且判断是否创建成功。
  2. 将头结点前驱指针设置为头结点，后继指针设置为头结点，形成一个闭环。
  3. 通过循环依次创建结点，并追加到链表末尾。
  4. 返回成功。

代码实现如下：

// 双向循环链表初始化
Status creatLinkList(LinkList *L){
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) {
        return ERROR;
    }
    (*L)->next = (*L);
    (*L)->prior = (*L);
    //新增数据
    LinkList p = *L;
    for(int i=0; i < 10;i++){
        //1.创建1个临时的结点
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->data = i;
        //2.为新增的结点建立双向链表关系
        //temp是p的后继
        p->next = temp;
        //temp的前驱是p
        temp->prior = p;
        //temp的后继是*L
        temp->next = (*L);
        //(*L)的前驱是新建的temp
        (*L)->prior = temp;
        //p要记录最后的结点的位置,方便下一次插入
        p = p->next;
    }
    return OK;
}

2.2 双向循环链表插入结点

思路：

  1. 创建结点指针p，并指向头结点。
  2. 遍历查找到插入位置前一个结点p。
  3. 创建新增节点temp，并赋值。
  4. 修改temp结点的前后关系。
    ①. 将结点temp的前驱结点设置为p。
    ②. 将结点temp的后继结点设置为p->next。
    ③. 将结点p的后继结点设置为temp。
    ④. 将结点temp的后继结点的前驱结点设置为temp。
  5. 返回OK。
    在这里插入图片描述

代码实现如下：

//双向循环链表插入元素
/*当插入位置超过链表长度则插入到链表末尾*/
Status LinkListInsert(LinkList *L, int index, ElemType e){
    //1.如果i>index 则返回error
    if (index < 1)  return ERROR;
    //2. 创建指针p,指向双向链表头
    LinkList p = (*L);
    int i = 1;
    //3.双向循环链表为空,则返回error
    if(*L == NULL) return ERROR;
    //4.找到插入前一个位置上的结点p
    while (i < index && p->next != *L) {
        p = p->next;
        i++;
    }
    //5.创建新结点temp
    LinkList temp = (LinkList)malloc(sizeof(Node));
    //6.temp 结点为空,则返回error
    if (temp == NULL) return ERROR;
    //7.将生成的新结点temp数据域赋值e.
    temp->data = e;
    //8.将结点temp 的前驱结点为p;
    temp->prior = p;
    //9.temp的后继结点指向p->next;
    temp->next = p->next;
    //10.p的后继结点为新结点temp;
    p->next = temp;
    //11.temp节点的下一个结点的前驱为temp结点
    temp->next->prior = temp;
    return OK;
}

2.3 双向循环链表删除结点

思路：

  1. 判断链表是否存在，不存在则return。
  2. 如果删除到只剩下首元结点了,则直接将*L置空。
  3. 创建结点指针，并指向首元结点，遍历查找到删除的结点temp，并将删除结点的值赋值给*e。
  4. 修改链表连接关系。
    ①. 修改被删除结点temp的前驱结点的后继指针。
    ②. 修改被删除结点temp的后继结点的前驱指针。
  5. 释放删除的结点temp。
  6. 返回OK。
    在这里插入图片描述

代码实现如下：

//双向循环链表删除结点
Status LinkListDelete(LinkList *L,int index,ElemType *e){
    int i = 1;
    LinkList temp = (*L)->next;
    if (*L == NULL) {
        return  ERROR;
    }
    //如果删除到只剩下首元结点了,则直接将*L置空;
    if(temp->next == *L){
        free(*L);
        (*L) = NULL;
        return OK;
    }
    //1.找到要删除的结点
    while (i < index) {
        temp = temp->next;
        i++;
    }
    //2.给e赋值要删除结点的数据域
    *e = temp->data;
    //3.修改被删除结点的前驱结点的后继指针
    temp->prior->next = temp->next;
    //4.修改被删除结点的后继结点的前驱指针
    temp->next->prior = temp->prior;
    //5. 删除结点temp
    free(temp);
    return OK;
}

2.4 双向循环链表遍历

思路：

  1. 判断链表是否为空，若为空，直接return。
  2. 创建结点指针temp，并指向首元结点。
  3. 循环遍历temp，若temp不为头结点，输出temp结点值，若temp为头结点，链表已经遍历到结尾，退出循环。

代码实现如下：

//遍历双向循环链表
Status Display(LinkList L){
    if (L == NULL) {
        printf("打印的双向循环链表为空!\n\n");
        return ERROR;
    }
    printf("双向循环链表内容:  ");
    LinkList p = L->next;
    while (p != L) {
        printf("%d  ",p->data);
        p = p->next;
    }
    printf("\n\n");
    return OK;
}
Daniel_Coder
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2. 线性表-链式存储-链表1
08-03
第二节 线性表-链式存储-链表回顾数组时间复杂度：访问：由于可以随机访问，O(1)插入：O(n)删除：O(n)静态操作：常数时间内完成动态操作：线性时间内完成此
线性表的链式存储结构——双向循环链表
qazxdewqs的博客
06-12 327
双向循环链表和单链表一样，是由一个个的节点组成，只是前者拥有两个指针域，一个指向前一个节点的地址另一个指向后一个节点。 双向链表的储存结构 typedef int data_t; typedef struct node{ data_t data; struct node *prior,*next; }dlinklist; 创建一个双向循环链表 首先需要创建一个头结点并初始化 dlinklis...
数据结构：线性表链式存储结构（双向链表） C语言版
C++++ ++
07-12 562
双向链表： 在单链表中，有了 next 指针，这使得查找下一结点的时间复杂度为 O(1)O(1)O(1) ，可是如果我们查找上一结点的话，那最坏的时间复杂度就是 O(n)O(n)O(n) 了，因为每次都要从头开始遍历查找。 双向链表就克服了这一缺陷。双向链表 ( Double Linked List ) 是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。 所以，在双向链表中的结点都有两个指针域，一个指向直接后继，了另一个指向直接前驱。 typedef struct _Tag_D_LinkList_N
线性表的双向链表存储结构
CodeMonkey
10-15 2836
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define ERROR 0 typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; struct L...
线性表的链式储存结构
Aaron6013的博客
05-14 1221
参考资料：《大话数据结构》 定义 还是可以想象成一串糖葫芦，可以通过一条线把他们串起来（首先要满足线性表的定义）。只不过现在这串糖葫芦上的每个山楂不是存在一起了，而且除了山楂，每个山楂都附有下一个山楂所在的位置。 我们把上面每一个山楂称为一个结点，把山楂称为数据域，下一个山楂所在的位置称为指针域。所有的结点（山楂）构成了线性链表。 把链表中第一个结点称为头结点，头结点的数据域不存储任何有效数据。 将头结点的存储位置称为头指针。 将第一个有效结点称为首结点。 同时规定，线性链表的最后一个结点的指针域为空.
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
热门推荐
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的实现， 链表的优点是“按需分配”，且增删方便，缺点是不能随机访问。在实际当中，有许多应用 是频繁变动，但并不要求随机访问，在这样的...
02-第2章线性表第7讲-双向链表和双向循环链表.pdf
12-16
02-第2章线性表第7讲-双向链表和双向循环链表.pdf
线性表的链式存储（链表）API及实现
03-27
链表是我们经常用到的一种数据结构，我们在学习数据结构的时候，第一个接触的一般就是线性表了，线性表...把线性表的链式存储结构，API实现及测试函数上传，配套我的文章《【数据结构】线性表的链式存储API及实现》。
线性表双向链表存储的实现
12-25
单链表结构定义、初始化、插入元素、删除元素、遍历显示、释放空间，易懂，学习。
【顺序表&链表】
m0_60900383的博客
07-18 330
1.线性表 2.顺序表 3.链表 4.顺序表和链表的区别和联系 5.顺序表和链表概念选择题
C语言双向链表实现对字符串的存储
weixin_51927215的博客
03-18 2408
双向链表实现字符串的存储—— 头文件结构体声明双向链表节点
数据结构——双向循环链表
qq_67611811的博客
08-28 1913
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 3553
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
双向循环链表
qq_52191699的博客
01-26 8849
链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
循环双向链表
qq_49567286的博客
06-01 843
初识循环双向链表
数据结构篇三：双向循环链表
忘忧.
05-01 1592
;前面我们学习了单链表的实现，我们发现它在进行从后往前查找的时候有很大的不便，为了解决这个问题，双向链表油然而生。它可以很好的解决单链表无法从后往前查找的困难。
数据结构之线性表中的双向循环链表【详解】
狂小伍的博客
11-28 1206
有头双向循环链表
线性表的顺序存储结构优于链表存储结构
最新发布
07-08
线性表的顺序存储结构和链表存储结构都有各自的优缺点，不能一概而论。 顺序存储结构的优点： 1. 存储密度高，每个元素都占用同样大小的存储空间，便于计算存储位置，随机访问元素非常快速。 2. 线性表长度固定，空间利用率高。 3. 元素之间的逻辑关系通过元素在空间中的相对位置来表示，容易理解。 顺序存储结构的缺点： 1. 线性表长度固定，插入和删除元素时需要移动大量元素，效率低下。 2. 插入和删除操作可能导致存储空间的浪费或不足，需要进行空间的重新分配，增加了编程难度。 3. 顺序存储结构只适合存储元素数量固定，查找和访问次数多的场景。 链表存储结构的优点： 1. 插入和删除元素时只需要修改指针，不需要移动元素，效率高。 2. 链表长度不固定，空间利用率高，可以动态分配内存空间。 3. 链表存储结构适合存储元素数量不固定，插入和删除操作频繁的场景。 链表存储结构的缺点： 1. 存储密度低，每个元素都需要额外的指针存储空间，增加了存储开销。 2. 访问元素需要遍历整个链表，效率相对较低。 3. 元素之间的逻辑关系通过指针来表示，理解起来相对困难。 因此，选择线性表的存储结构需要根据实际应用需求进行权衡和选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值