数据结构（05）——双向链表

最新推荐文章于 2023-09-19 22:02:23 发布
最新推荐文章于 2023-09-19 22:02:23 发布
阅读量365 收藏 1
点赞数
分类专栏： C C++ 文章标签： 数据结构 双向链表 数据结构双向链表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunsddd/article/details/100511671
版权
C++ 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
C
11 篇文章 0 订阅
订阅专栏

双向链表概念

可以在单链表的基础上给每个元素附加两个指针域，一个存储前一个元素的地址，一个存储

下一个元素的地址。这种链表称为双向链表.

结构体定义

typedef struct _LinkNode {
    int data; //结点的数据域
    struct _LinkNode *next; //下一个节点的指针域
    struct _LinkNode *prev; //上一个结点的指针域
}LinkNode, LinkList; //LinkList 为指向结构体 LNode 的指针类型

双向链表的初始化

typedef struct _DoubleLinkNode {
    int data; //结点的数据域
    struct _DoubleLinkNode *next; //下一个节点的指针域
    struct _DoubleLinkNode *prev; //上一个结点的指针域
}DbLinkNode, DbLinkList; //LinkList 为指向结构体 LNode 的指针类型

bool DbInit_List(DbLinkList* &L)//构造一个空的双向链表 L
{
    L=new DbLinkNode; //生成新结点作为头结点，用头指针 L 指向头结点
    if(!L)return false; //生成结点失败
    L->next=NULL; //头结点的 next 指针域置空
    L->prev=NULL; //头结点的指针域置空
    L->data = -1;
    return true;
}

双向链表增加元素——前插法

//前插法
bool DbListInsert_front(DbLinkList* &L, DbLinkNode *node){
    if(!L || !node) return false;

    //1.只有头节点
    if(L->next==NULL){
        node->next=NULL;
        node->prev=L; //新节点 prev 指针指向头节点
        L->next=node; //头节点 next 指针指向新节点
    }else {
        L->next->prev=node; //第二个节点的 prev 指向新节点
        node->next = L->next; //新节点 next 指针指向第二个节点
        node->prev=L; //新节点 prev 指针指向头节点
        L->next=node; //头节点 next 指针指向新节点，完成插入
    }
    return true;
}

双向链表增加元素——尾插法

//尾插法
bool DbListInsert_back(DbLinkList* &L, DbLinkNode *node){
    DbLinkNode *last = NULL;
    if(!L || !node) return false;
    last = L;
    while(last->next) last = last->next;
    node->next = NULL;
    last->next = node;
    node->prev = last;
    return true;
}

双向链表增加元素——任意位置插入

//指定位置插入
bool DbLink_Insert(DbLinkList* &L, int i, int &e){
    if(!L||!L->next) return false;
    if(i<1) return false;
    int j =0;
    DbLinkList *p, *s;
    p = L;
    while(p && j<i){//查找位置为 i 的结点，p 指向该结点
        p = p->next;
        j++;
    }
    if(!p || j!=i){
        cout<<"不存在节点："<<i<<endl;
        return false;
    }
    cout<<"p: "<<p<<endl;
    s=new DbLinkNode;//生成新节点
    s->data = e;
    s->next = p;
    s->prev = p->prev;
    p->prev->next = s;
    p->prev = s;
    return true;
}

双向链表的遍历

//双向链表的遍历输出
void DbLink_Print(DbLinkList* &L ){
    DbLinkNode *p = NULL;
    if(!L){
        cout<<"链表为空."<<endl;
        return ;
    }
    p = L;
    while(p->next){
        cout<<p->next->data<<"\t";
        p = p->next;
    }

    //逆向打印
    cout<<endl<<"逆向打印"<<endl;
    while(p){
        cout<<p->data<<"\t";
        p = p->prev;
    }
    cout<<endl;
}

双向链表获取元素

bool DbLink_GetElem(DbLinkList* &L, int i, int &e)//双向链表的取值
{
    //在带头结点的双向链表 L 中查找第 i 个元素
    //用 e 记录 L 中第 i 个数据元素的值
    int index;
    DbLinkList *p;
    if(!L || !L->next) return false;
    p = L->next;
    index = 1;
    while(p && index<i){//顺链表向后扫描，直到 p 指向第 i 个元素或 p 为空
        p = p->next; //p 指向下一个结点
        index++; //计数器 index 相应加 1
    }

    if(!p || index>i){
        return false; //i 值不合法,i＞n 或 i<=0
    }
    e=p->data;
    return true;
}

双向链表删除元素

//任意位置删除
bool DbLink_Delete(DbLinkList* &L, int i) //双向链表的删除
{
    DbLinkList *p;
    int index = 0;
    if(!L || !L->next){
        cout<<"双向链表为空!"<<endl;
        return false;
    }
    if(i<1) return false; //不能删除头节点
    p=L;
    while(p && index<i){
        p = p->next;
        index++;
    }
    if(!p){ //当节点不存在时，返回失败
        return false;
    }
    p->prev->next=p->next; //改变删除结点前驱结点的 next 指针域
    if(p->next){
        p->next->prev = p->prev; //改变删除节点后继节点的 prev 指针域
    }

    delete p; //释放被删除结点的空间
    return true;
}

双向链表销毁

void DbLink_Destroy(DbLinkList* &L) //双向链表的销毁
{
    //定义临时节点 p 指向头节点
    DbLinkList *p = L;
    cout<<"销毁链表!"<<endl;
    while(p){
        L=L->next;//L 指向下一个节点
        cout<<"删除元素: "<<p->data<<endl;
        delete p; //删除当前节点
        p = L; //p 移向下一个节点
    }
}

完整代码实现

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

using namespace std;

typedef struct _DoubleLinkNode {
    int data; //结点的数据域
    struct _DoubleLinkNode *next; //下一个节点的指针域
    struct _DoubleLinkNode *prev; //上一个结点的指针域
}DbLinkNode, DbLinkList; //LinkList 为指向结构体 LNode 的指针类型

bool DbList_Init(DbLinkList* &L)//构造一个空的双向链表 L
{
    L=new DbLinkNode; //生成新结点作为头结点，用头指针 L 指向头结点
    if(!L)return false; //生成结点失败
    L->next=NULL; //头结点的 next 指针域置空
    L->prev=NULL; //头结点的 prev 指针域置空
    L->data = -1;
    return true;
}

//前插法
bool DbListInsert_front(DbLinkList* &L, DbLinkNode *node){

    if(!L || !node) return false;

    //1.只有头节点
    if(L->next==NULL){
        node->next=NULL;
        node->prev=L; //新节点 prev 指针指向头节点
        L->next=node; //头节点 next 指针指向新节点
    }else {
        L->next->prev=node; //第二个节点的 prev 指向新节点
        node->next = L->next; //新节点 next 指针指向第二个节点
        node->prev=L; //新节点 prev 指针指向头节点
        L->next=node; //头节点 next 指针指向新节点，完成插入
    }
    return true;
}

//尾插法
bool DbListInsert_back(DbLinkList* &L, DbLinkNode *node){
    DbLinkNode *last = NULL;
    if(!L || !node) return false;
    last = L;
    while(last->next) last = last->next;
    node->next = NULL;
    last->next = node;
    node->prev = last;
    return true;
}

//指定位置插入
bool DbLink_Insert(DbLinkList* &L, int i, int &e){
    if(!L||!L->next) return false;
    if(i<1) return false;
    int j =0;
    DbLinkList *p, *s;
    p = L;
    while(p && j<i){//查找位置为 i 的结点，p 指向该结点
        p = p->next;
        j++;
    }
    if(!p || j!=i){
        cout<<"不存在节点："<<i<<endl;
        return false;
    }
    cout<<"p: "<<p<<endl;
    s=new DbLinkNode;//生成新节点
    s->data = e;
    s->next = p;
    s->prev = p->prev;
    p->prev->next = s;
    p->prev = s;
    return true;
}

void DbLink_Print(DbLinkList* &L ){
    DbLinkNode *p = NULL;
    if(!L){
        cout<<"链表为空."<<endl;
        return ;
    }
    p = L;
    while(p->next){
        cout<<p->next->data<<"\t";
        p = p->next;
    }

    //逆向打印
    cout<<endl<<"逆向打印"<<endl;
    while(p){
        cout<<p->data<<"\t";
        p = p->prev;
    }
    cout<<endl;
}

bool DbLink_GetElem(DbLinkList* &L, int i, int &e)//双向链表的取值
{
    //在带头结点的双向链表 L 中查找第 i 个元素
    //用 e 记录 L 中第 i 个数据元素的值
    int index;
    DbLinkList *p;
    if(!L || !L->next) return false;
    p = L->next;
    index = 1;
    while(p && index<i){//顺链表向后扫描，直到 p 指向第 i 个元素或 p 为空
        p = p->next; //p 指向下一个结点
        index++; //计数器 index 相应加 1
    }
    if(!p || index>i){
        return false; //i 值不合法,i＞n 或 i<=0
    }
    e=p->data;
    return true;
}

bool DbLink_Delete(DbLinkList* &L, int i) //双向链表的删除
{
    DbLinkList *p;
    int index = 0;
    if(!L || !L->next){
        cout<<"双向链表为空!"<<endl;
        return false;
    }
    if(i<1) return false; //不能删除头节点
    p=L;
    while(p && index<i){
        p = p->next;
        index++;
    }
    if(!p){ //当节点不存在时，返回失败
        return false;
    }
    p->prev->next=p->next; //改变删除结点前驱结点的 next 指针域
    p->next->prev = p->prev; //改变删除节点后继节点的 prev 指针域
    delete p; //释放被删除结点的空间
    return true;
}

void DbLink_Destroy(DbLinkList* &L) //双向链表的销毁
{
    //定义临时节点 p 指向头节点
    DbLinkList *p = L;
    cout<<"销毁链表!"<<endl;
    while(p){
        L=L->next;//L 指向下一个节点
        cout<<"删除元素: "<<p->data<<endl;
        delete p; //删除当前节点
        p = L; //p 移向下一个节点
    }
}

int main(void){
    DbLinkList *L = NULL;
    DbLinkNode *s = NULL;

    //1. 初始化一个空的双向链表
    DbList_Init(L);

    //2. 使用前插法插入数据
    int n;
    cout<<"前插法创建双向链表"<<endl;
    std::cout<<"请输入元素个数 n：";
    cin>>n;
    cout<<"\n 请依次输入 n 个元素：" <<endl;
    while(n>0){
        s = new DbLinkNode; //生成新节点 s
        cin>>s->data;
        DbListInsert_front(L, s);
        n--;
    }

    //3. 使用尾插法插入数据
    cout<<"尾插法创建双向链表"<<endl;
    std::cout<<"请输入元素个数 n：";
    cin>>n;
    cout<<"\n 请依次输入 n 个元素：" <<endl;
    while(n>0){
        s = new DbLinkNode; //生成新节点 s
        cin>>s->data;
        DbListInsert_back(L, s);
        n--;
    }

    //4. 双向链表的输出
    DbLink_Print(L);

    //5. 任意位置插入元素
    for(int j=0; j<3; j++){
        int i, x;
        cout << "请输入插入的位置和元素（用空格隔开）:";
        cin >> i;
        cin >> x;
        if(DbLink_Insert(L, i, x)){
            cout << "插入成功.\n\n";
        }else{
            cout << "插入失败!\n\n";
        }
        DbLink_Print(L);
    }

    //6. 双向链表根据位置获取元素
    int element = 0;
    if(DbLink_GetElem(L, 2, element)){
        cout<<"获取第二个元素成功, 值："<<element<<endl;
    }else {
        cout<<"获取第二个元素失败!"<<endl;
    }

    //7. 双向链表删除元素
    if(DbLink_Delete(L, 2)){
        cout<<"删除第 2 个元素成功!"<<endl;
        DbLink_Print(L);
    }else {
        cout<<"删除第 2 个元素失败!"<<endl;
    }
    if(DbLink_Delete(L, 1)){
        cout<<"删除第 1 个元素成功!"<<endl;
        DbLink_Print(L);
    }else {
        cout<<"删除第 1 个元素失败!"<<endl;
    }

    //8. 销毁双向链表
    DbLink_Destroy(L);
    system("pause");
    return 0;
}

 

萝卜兽编程
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之双向循环链表
未思
02-06 912
算法与数据结构之双向循环链表
双向链表及其应用——实现多项式的加法及乘法
10-23
双向链表是一种线性数据结构，每个节点包含两个指针，分别指向其前一个节点和后一个节点。这种设计使得我们可以从前向后或从后向前遍历链表，提高了操作的灵活性。在C++中，我们通常通过定义一个类来表示链表节点，...
数据结构之双向链表
Blooming death的博客
08-26 369
双向链表 1）、双向链表的构造：head节点、data、next（指向下一个）、pre（指向上一个） 2）、双向链表的添加、遍历、删除、修改的操作思想===>代码实现 a．遍历；方式和单链表一样，只是可以向前查找，向后查找 b．添加(默认添加到双向链表的最后)；先找到双向链表的最后这个节点，temp.next=newHead 最后一 个节点指向新节点，新节点的pre指向我们的最后一个节点，newHead.pre=temp; c．修改：思路和原来的单项链表一样 d．删除：双向链表可以实现自我删除，直接
C语言之双向链表
qq_35600620的博客
01-10 1539
一、双向链表 在上一篇文章我们已经介绍了单向链表，了解了其具体构造及其基本操作，我们也能发现其部分缺点，查找数据和删除数据的时候都必须从链表头指针开始挨个遍历，直到找到目标节点。 双向链表的双向指的的就是我们遍历链表的时候可以正序遍历也可逆序遍历，链表内的节点不止与下一个节点有关系，与上一个节点同样有关系。具有两个方向。 1.1双向链表的构造如下图所示 根据图我们可以看到，双向链表和单向链...
链表的基本操作 超详细解析
xiaohe857的博客
10-20 1862
题目： 编写函数，创建一个带头结点的单链表（数据自拟）； 编写函数，在单链表的指定位置插入一个元素； 编写函数，在单链表的指定位置删除一个元素； 编写函数，将两个有序链表合并成一个新的有序链表； 解答： 首先做一个备注：L->next有两层含义，可以表示L的后继节点指针，又可表示L的指针域，（补充：链表每个节点分为数据域和指针域，（单链表的指针域只有后继指针域，双链表的指针域分为前趋指针域和后继指针域））。第一，当它在等号右边时（即X = L->next形式）一般是指将X指针指向头节点
C语言中L.next 和L-＞next 的区别
最新发布
weixin_36888745的博客
09-19 1473
在 C 语言中，L.next 和 L->next 是两种不同的方式用于访问结构体（或指向结构体的指针）的成员。
Rt-Thread之双向链表学习
weixin_42536940的博客
01-29 493
一、定义链表节点数据类型 struct rt_list_node { struct rt_list_node *next; /* 指向后一个节点 */ struct rt_list_node *prev; /* 指向前一个节点 */ }; typedef struct rt_list_node rt_list_t; 二、在双向链表头部插入一个节点 l指的是第一个节点，n指新插入的节点。 新插入节点的时候，新节点把两边都断开了联系，所以左右两边需要建立好连接。 先看右边 第一步、看的时候主要是看原
漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
Java算法实例-双向链表操作
08-22
本实例聚焦于Java中的一个重要数据结构——双向链表，它在很多场景下都有着广泛的应用。双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的...
实用算法实验_双向链表
11-10
创建空的双向链表； 逐字符读取键盘输入的合法字符串，并依次插入到双向链表中。具体的，对于当前读取的字符， 构造其对应的结点。 利用头插法（或尾插法）将该结点按照键盘输入的顺序插入到双向链表中。 3、判断双向链表中各节点是否首尾对称，并打印出是否首尾对称的提示信息。（【提示】：可以利用双向链表的头指针和尾指针，其中头指针往链表尾部移动，尾指针向链表头部方向移动。当头尾指针最后能相遇时，则可认为输入字符串是首尾对称的。）
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
双向链表分析
shaoyunzhe的专栏
05-25 1389
1. 位置 list.h   2. 数据结构 struct list_head struct list_head {     struct list_head *next, *prev; };   3. 使用方法 1. 应用时，在链表的头节点及中间节点的数据结构中包含struct list_head成员； 2. 头节点的struct list_
数据结构单链表
weixin_45889436的博客
09-09 645
#include <iostream> #include <stdio.h> //队列 //单链表 //节点的定义 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //头插法 LinkList headinsert(LinkList &L){ LNode *s ;int X; L=(LNode*)malloc(sizeof(LNode)); .
学习c语言的第十八天
weixin_46007132的博客
03-17 1145
合并两个无序链表使其有序 输入：链表l1的各个结点的值，链表l2的各个结点的值。 输出：输入的第一个链表的值，输入的第二个链表的值，合并后的链表的值，两个链表合并后以由小至大的顺序输出的值。 优化目标：有两种方法，第一种是先合并为一个链表，再使用链表内部排序使其有序。第二种是先使得两个链表有序，再使其生成一个新的有序链表。 第一种： #include<stdio.h> #include<stdlib.h> typedef struct LNode * linklist;
数据结构之线性表(五)——单链表(4 单链表的建立)
daocaoren_的博客
07-19 2080
建立单链表的方法有两种：头插法和尾插法。 头插法建立单链表 头插法：元素插入到链表头部，也叫前插法。 算法步骤： 1.从一个空表开始，重复读入数据。 2.生成新结点，将读入数据存放到新结点的数据域中。 3.从最后一个结点开始，依次将各结点插入到链表的前端。 例子： 建立链表L (a,b,c,d,e) 从线性表中最后一个元素开始，依次插入到链表的前面。 具体做法： 1.建立头节点。L = n...
顺序表和链表
m0_51364183的博客
08-17 234
顺序表和链表都是线性表的一种,还有队列和栈,以及字符串等等. 一.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般用数组来存储. 1.顺序表的分类: \(1)静态顺序表(定长的) #define N 8 typedef int ElemType typedef struct SeqList { ElemType arr[N];//定长数组 size_t size;//数组长度 }SeqList; (2)动态顺序表(容量不够自动扩容的) typedef s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

萝卜兽编程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值