【数据结构】【王道】【线性表】双链表的实现及基本操作（可直接运行）

已于 2022-07-21 09:57:46 修改
阅读量653 收藏 10
点赞数 4
分类专栏： 数据结构 c/c++ 文章标签： 数据结构
于 2022-07-12 10:05:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/treesorshining/article/details/125737052
版权

总目录

文章目录


各部分的解释已经以注释形式写于代码中。

1.基本操作

1.1 结构体定义

typedef struct DNode {  // 定义双链表结点类型
    int data;   // 数据域
    // 单链表只能单向检索，无法逆向检索
    // 双链表有前驱以及后继指针，指向前驱以及后继结点
    // 但由于双链表多了一个指针，每个结点所占据的空间也会增加
    struct DNode *prior, *next; // 前驱和后继结点指针
} DNode, *DLinklist;

1.2 初始化

// 初始化
bool InitDLinkList(DLinklist &L) {
    // 为头结点申请分配空间
    L = (DNode *)malloc(sizeof(DNode));
    // 内存不足的情况
    if(L == NULL) {
        return false;
    }
    // 头结点的prior指针永远指向NULL
    L->prior = NULL;
    // 头结点之后暂时无结点，设为NULL
    L->next = NULL;
    return true;
}

1.3 判空

// 判断双链表是否为空（带头结点）
bool Empty(DLinklist L) {
    // 头结点指针域指向空即双链表为空
    if(L->next == NULL) {
        return true;
    } else {
        return false;
    }
}

1.4 结点后插入_1

// 双链表插入
// 在p结点后插入s结点
bool InsertNextDNode(DNode *p, DNode *s) {
    // 无效输入
    if(p == NULL || s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

1.5 结点后插入_2

// 双链表插入
// 由于王道书上给出的示例是插入结点，这里给出一个插入数据的实现
bool InsertNextDNode_2(DNode *p, int e) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 申请空间
    DNode* s = (DNode*)malloc(sizeof(DNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->data = e;
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

1.6 按位序插入

// 按位序插入
// 在第i个位置插入元素e
bool ListInsert(DLinklist &L, int i, int e) {
    // 判断插入位序是否存在问题
    if(i < 1)
        return false;
    DNode *p;   // 指针p指向当前扫描到的结点
    int j = 0;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向头结点
    // 通过循环，找到第i-1个结点
    // 如果i大于链表长度，则不可插入，此时p指向最后结点的指针域，即NULL
    while(p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    // p值为NULL说明遍历完成后仍未为找到位序为i的结点，说明i大于链表长度，i不合法
    if (p == NULL) {
        return false;
    }
    // 在第i-1个结点后插入新结点
    DNode *s = (DNode *)malloc(sizeof(DNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->data = e;
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

1.7 删除后继结点

// 删除p结点的后继结点
bool DeleteNextDNode(DNode *p) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 找到p的后继结点q
    DNode *q = p->next;
    // p为最后一个结点的情况，next指针指向NULL，无法执行删除操作
    if(q == NULL) {
        return false;
    }
    // 用前驱结点的后继指针指向后继结点
    p->next = q->next;
    // q为最后一个结点的情况
    if(q->next != NULL) {
        // 若q不是最后一个结点，那么就用q后继结点的前驱指针指向前驱结点
        q->next->prior = p;
    }
    // 不要忘记释放空间！！！
    free(q);
    return true;
}

1.8 按位查找

// 按位查找，返回第i个元素
DNode* GetElem(DLinklist L, int i) {
    // 判断插入位序是否存在问题
    // 由于此是带头结点的情况，而头结点可以视作是第0个结点
    // 所以与之前遍历情况不同
    if(i < 0)
        return NULL;
    DNode *p;   // 指针p指向当前扫描到的结点
    int j = 0;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向头结点
    // 通过循环，找到第i个结点
    // 如果i大于链表长度，则找不到此节点，此时p指向最后结点的指针域，即NULL
    // 如果i初始为0，会直接返回头结点地址
    while(p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

1.9 按值查找

// 按值查找，找到数据域等于e的结点
DNode* LocateElem(DLinklist L, int e) {
    DNode* p = L->next;
    // 从第一个结点开始查找数据域为e的结点
    // 找不到，则会在遍历后指向NULL
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;
}

1.10 销毁链表

// 销毁双链表
void DestoryList(DLinklist &L) {
    // 循环释放各个数据节点的空间
    while(L->next != NULL) {
        DeleteNextDNode(L);
    }
    // 释放头结点空间
    free(L);
    // 头指针指向NULL
    L = NULL;
}

1.11 输出所有链表元素

// 输出所有链表元素
void PrintList(DLinklist L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    DNode* p = L->next;
    while(p !=  NULL) {
        printf("%d  ", p->data);
        p = p->next;
    }
    printf("\n");
}

2.完整代码

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

typedef struct DNode {  // 定义双链表结点类型
    int data;   // 数据域
    // 单链表只能单向检索，无法逆向检索
    // 双链表有前驱以及后继指针，指向前驱以及后继结点
    // 但由于双链表多了一个指针，每个结点所占据的空间也会增加
    struct DNode *prior, *next; // 前驱和后继结点指针
} DNode, *DLinklist;

// 初始化
bool InitDLinkList(DLinklist &L) {
    // 为头结点申请分配空间
    L = (DNode *)malloc(sizeof(DNode));
    // 内存不足的情况
    if(L == NULL) {
        return false;
    }
    // 头结点的prior指针永远指向NULL
    L->prior = NULL;
    // 头结点之后暂时无结点，设为NULL
    L->next = NULL;
    return true;
}

// 判断双链表是否为空（带头结点）
bool Empty(DLinklist L) {
    // 头结点指针域指向空即双链表为空
    if(L->next == NULL) {
        return true;
    } else {
        return false;
    }
}

// 双链表插入
// 在p结点后插入s结点
bool InsertNextDNode(DNode *p, DNode *s) {
    // 无效输入
    if(p == NULL || s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

// 双链表插入
// 由于王道书上给出的示例是插入结点，这里给出一个插入数据的实现
bool InsertNextDNode_2(DNode *p, int e) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 申请空间
    DNode* s = (DNode*)malloc(sizeof(DNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->data = e;
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

// 按位序插入
// 在第i个位置插入元素e
bool ListInsert(DLinklist &L, int i, int e) {
    // 判断插入位序是否存在问题
    if(i < 1)
        return false;
    DNode *p;   // 指针p指向当前扫描到的结点
    int j = 0;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向头结点
    // 通过循环，找到第i-1个结点
    // 如果i大于链表长度，则不可插入，此时p指向最后结点的指针域，即NULL
    while(p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    // p值为NULL说明遍历完成后仍未为找到位序为i的结点，说明i大于链表长度，i不合法
    if (p == NULL) {
        return false;
    }
    // 在第i-1个结点后插入新结点
    DNode *s = (DNode *)malloc(sizeof(DNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 先令s后继指针指向后继结点
    // 再令后继结点的前驱指针指向s
    // 再令s前驱指针指向p
    // 最后令前驱结点后继指针指向s
    // 顺序注意不要在连接前断开即可
    s->data = e;
    s->next = p->next;
    // 如果p结点无后继结点，后继指针指向NULL取不了前驱指针，会报错
    if(p->next != NULL) {
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

// 删除p结点的后继结点
bool DeleteNextDNode(DNode *p) {
    // 无效输入
    if(p == NULL) {
        return false;
    }
    // 找到p的后继结点q
    DNode *q = p->next;
    // p为最后一个结点的情况，next指针指向NULL，无法执行删除操作
    if(q == NULL) {
        return false;
    }
    // 用前驱结点的后继指针指向后继结点
    p->next = q->next;
    // q为最后一个结点的情况
    if(q->next != NULL) {
        // 若q不是最后一个结点，那么就用q后继结点的前驱指针指向前驱结点
        q->next->prior = p;
    }
    // 不要忘记释放空间！！！
    free(q);
    return true;
}

// 销毁双链表
void DestoryList(DLinklist &L) {
    // 循环释放各个数据节点的空间
    while(L->next != NULL) {
        DeleteNextDNode(L);
    }
    // 释放头结点空间
    free(L);
    // 头指针指向NULL
    L = NULL;
}

// 按位查找，返回第i个元素
DNode* GetElem(DLinklist L, int i) {
    // 判断插入位序是否存在问题
    // 由于此是带头结点的情况，而头结点可以视作是第0个结点
    // 所以与之前遍历情况不同
    if(i < 0)
        return NULL;
    DNode *p;   // 指针p指向当前扫描到的结点
    int j = 0;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向头结点
    // 通过循环，找到第i个结点
    // 如果i大于链表长度，则找不到此节点，此时p指向最后结点的指针域，即NULL
    // 如果i初始为0，会直接返回头结点地址
    while(p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找，找到数据域等于e的结点
DNode* LocateElem(DLinklist L, int e) {
    DNode* p = L->next;
    // 从第一个结点开始查找数据域为e的结点
    // 找不到，则会在遍历后指向NULL
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;
}

// 输出所有链表元素
void PrintList(DLinklist L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    DNode* p = L->next;
    while(p !=  NULL) {
        printf("%d  ", p->data);
        p = p->next;
    }
    // 跳过头结点将循环条件改为p->prior != NULL即可
    // while(p != NULL) {
    //     // 后向遍历
    //     p = p->next;
    //     // 前向遍历
    //     p = p->prior;
    // }
    printf("\n");
}

int main() {
    DLinklist L;
    InitDLinkList(L);
    PrintList(L);
    ListInsert(L, 1, 1);
    ListInsert(L, 2, 5);
    ListInsert(L, 3, 7);
    PrintList(L);
    InsertNextDNode_2(GetElem(L, 1), 3);
    PrintList(L);
    printf("locate_3:%d\n", LocateElem(L, 3)->data);
    // 删除的是下一个结点
    DeleteNextDNode(GetElem(L, 2));
    PrintList(L);
    DestoryList(L);
}

3.运行截图

在这里插入图片描述

Silver Star
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数据结构之线性表(顺序表与链表)--王道
weixin_64144469的博客
05-21 632
目录 2.1线性表的定义和基本操作 2.1.1线性表的定义 2.1.2线性表的基本操作 2.2线性表的顺序表示 2.2.1顺序表的定义 2.2.2顺序表上基本操作的实现 2.3线性表的链式表示 2.3.1单链表的定义 2.3.2单链表上基本操作的实现 1.用头插法建立单链表 2.用尾插法 3.按序号查找结点值 4.按值查找表结点 5.插入结点操作 6.删除结点操作 7.求表长操作 2.3.3双链表 1.双链表的插入 2.双链表的删除 2.3.4循环链表...
线性表双向链表存储的实现
12-25
单链表结构定义、初始化、插入元素、删除元素、遍历显示、释放空间，易懂，学习。
线性表之双向链表的建立、查找、插入和删除（附C++程序）
ch18328071580的博客
07-07 3657
本文详细介绍了数据结构的双链表的定义，以及双向链表的建立、查找、插入和删除
【数据结构】【王道】【线性表】循环链表的实现及基本操作（可直接运行）
treesorshining的博客
07-12 506
总目录 由于循环链表尾部并未指向空，而是指向头指针。循环单链表尾结点指针域指向头结点；循环双链表尾结点后继指针指向头结点，头结点前驱指针指向尾节点。故而各类基本操作与之前单链表、双链表基本操作相差不大，主要就是在于对尾结点的处理问题，之前非循环链表尾结点指向空，如果要执行插入、删除等可能需要对后继结点取指针域的操作会导致报错，而循环链表就没有这个问题，因为它尾结点并非指向空。综上，在此处不会给出全部的基本操作，仅给出简单插入和删除作为示例，可与博主之前实现单链表、双链表的文章参照查看，改动主要是对于尾结点的
2024年王道考研数据结构线性表—链表题目
qq_51536841的博客
07-18 515
24王道考研复习书数据结构线性表——链表
王道数据结构——双链表、循环双链表实现
qq_42242452的博客
05-02 821
王道考研双链表、循环双链表
考研数据结构——线性表（顺序表&链表）最全！含代码！
给你糖ya的博客
03-20 1046
和顺序表相比，单链表是链式存储而不是顺序存储，即在内存中是离散存储的，每个结点除了存放数据元素外还要存放指向下一个节点的指针；不需要大片连续空间，改变容量方便；但是不可随机存取，要耗费一定空间存放指针。typedef struct DNode { //定义单链表的结点类型int data;//每个结点存放一个数据元素//prior指向前驱结点，next指向后继结点单链表的各个结点离散地分布在内存中的各个地方；静态链表会分配一整块连续的内存空间来存放各个结点，各个结点不一定连续但都在这一块内存中。
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 22万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
王道数据结构—线性表的存储结构和基本操作
SSilverdeww的博客
10-10 215
王道数据结构 ——线性表的存储结构及基本操作
王道数据结构笔记【线性表(顺序表、链表）】
Dys_debug的博客
08-18 1196
2022年7月整理
线性表（双链表）的基本操作实现
06-26
线性表（双链表）的基本操作实现 ...本次课程设计实现了线性表（双链表）的基本操作，掌握了线性表的基本概念、双链表的基本概念、线性表的基本操作和C语言的应用等知识点，对于数据结构和算法的学习具有重要的意义。
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构实验一线性表的基本操作.docx
03-28
数据结构实验一线性表的基本操作 一、线性表的概念和类型 ...数据结构实验一线性表的基本操作的实验结果证明了线性表的基本操作的实现，并且实现了多项式相加的功能。实验结果表明了线性表的重要性和实用性。
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
【数据结构】单链表的增删改查
2302_78914800的博客
07-25 753
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 632
【代码】c语言（7.23）
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 773
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 832
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Silver Star

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值