C++数据结构之双链表详解

最新推荐文章于 2024-06-15 09:00:00 发布
最新推荐文章于 2024-06-15 09:00:00 发布
阅读量1.1k 收藏 5
点赞数 4
分类专栏： 数据结构，算法与思维 文章标签： 数据结构 c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suren_jun/article/details/126886869
版权

这里头节点是不存储数据的，且单向链表的操作，双向链表都可以做到，这里讲一下双向链表的特点。

如果想看一些基础的增删改查工作，直接查看单链表即可

C++数据结构之单链表


废话不多说，直接上干货

1. 双向链表的结构定义
//定义链表
typedef struct Node{
    int data;//存放数据
    Node* pre; //指向上一个节点
    Node* next;//指向下一个节点
    Node(): data(0),pre(NULL),next(NULL){};
    Node(int x, Node* node): data(x),pre(node),next(NULL){};
    Node(int x, Node* node, Node* node2): data(x),pre(node),next(node2){};
}*ListNode;

上述定义了一个双向链表的节点，包含数据，前驱指针和后继指针。

  • 这里采用初始化列表的方式初始化Node，不仅仅是因为这样写简洁方便，而是这种方式在有些时候是比在函数体里面初始化更加的高效。
  • 使用typedef的方式在下方定义的*ListNode是一个结构体类型而不是一个变量。

这里采用了三种构造函数，包括有参的重载。

2. 建立一个线性链表

因为这里我们写了链表的一个有参构造，这样初始化链表就变得非常简单

template<typename T>
void CreateList(ListNode &link_list, T arr, int len){
    Node* p = link_list;
    for(int i=0; i<len; i++){
        p->next = new Node(arr[i], p);  //每一步都设置前驱节点
        p = p->next;
    }
}

void ShowList(const ListNode &link_list){
    Node* p = link_list->next;
    if(NULL == p) return;
    while(NULL != p->next){
        cout << p->data << "\t";
        p = p->next;
    }
    cout<<p->data << endl;
}
int main(void){

    ListNode link_list = new Node();

    vector<int> a = {1,2,3,4,5};
    CreateList(link_list, a, a.size());
    Node *p = link_list->next->next;
    cout<<p->pre->data<<endl;
    ShowList(link_list);

    system("pause");
    return 0;
}

直接调用有参构造就可以了。

添加节点

增删改查操作，单链表能做的，双向链表也能做，不过有一些区别

  • 尾部插入节点：前驱节点的后继指针指向新节点，新节点的前驱指针指向前驱节点，总计2个指针。
  • 增加中间节点：双链表在添加新节点时，如果是中间节点，那么需要修改前一个节点的后继指针，后一个节点的前驱指针，以及新节点的前后指针，总计4个指针。
//插入尾部节点
void InsertRear(ListNode &link_list, int val){
    Node *p = link_list;
    while(NULL != p->next){
        p = p->next;
    }
    p->next = new Node(val, p);
}

//插入中间节点
void InsertInside(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list;
    while(NULL != p->next){
        if(count == index){
            Node *temp = new Node(val, p); //新节点的前驱指针指向p
            temp->next = p->next; //新节点的后继指针指向后一个节点
            p->next->pre = temp; //后继节点的前驱指针指向新节点
            p->next = temp; //前驱节点的后继指针指向新节点
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"插入失败"<<endl;
}
删除节点
  • 删除尾部元素：修改前驱节点的后继指针即可
  • 删除中间元素：删除中间节点，需要修改前一个节点的后继指针，后一个节点的前驱指针，总计2个指针。
void RemoveRear(ListNode &link_list){
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }else if(NULL == p->next){
        delete p;
        link_list->next = NULL;
    }
    while(NULL != p->next->next){
        p = p->next;
    }
    delete p->next;
    p->next = NULL;
}

void RemoveInside(ListNode &link_list, int index){
    
    Node *p = link_list;
    if(NULL == p->next){
        cout << "链表为空" << endl;
        return;
    }
    int count = 0;
    while(NULL != p->next->next){
        if(count == index){
            Node* temp = p->next->next; //得到后继节点
            temp->pre = p; //修改后继节点的前驱指针
            delete p->next; //删除节点
            p->next = temp; //修改前驱节点的后继指针
            return;
        }
        p = p->next;
        count++;
    }
    cout << "index 超出索引" << endl;
}

双向链表麻烦的地方就在于指针的指向操纵要更加的复杂一点，但是同样灵活性也更加的好一些。

查看节点
Node* FindNode(const ListNode &link_list, int val){
    Node *p = link_list->next;
    while(NULL != p){
        if(p->data == val) return p;
        p = p->next;
    }
    return NULL;
}

这个和单链表是一样的

修改节点
void ChangeNode(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }
    while(NULL != p->next){
        if(count == index){
            p->data = val;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"修改失败"<<endl;
}
总结

具体的问题需要具体的分析，目前还没遇到过什么问题使用双链表才是妙手的情况，所以这里暂时就介绍基础的操作。


老规矩，有用，希望能送上你的二连，感谢！

附录

全部代码

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<string>
#include<vector>

using namespace std;

//定义链表
typedef struct Node{
    int data;//存放数据
    Node* pre; //指向上一个节点
    Node* next;//指向下一个节点
    Node(): data(0),pre(NULL),next(NULL){};
    Node(int x, Node* node): data(x),pre(node),next(NULL){};
    Node(int x, Node* node, Node* node2): data(x),pre(node),next(node2){};
}*ListNode;

template<typename T>
void CreateList(ListNode &link_list, T arr, int len){
    Node* p = link_list;
    for(int i=0; i<len; i++){
        p->next = new Node(arr[i], p);
        p = p->next;
    }
}

void ShowList(const ListNode &link_list){
    Node* p = link_list->next;
    if(NULL == p) return;
    while(NULL != p->next){
        cout << p->data << "\t";
        p = p->next;
    }
    cout<<p->data << endl;
}

Node* FindNode(const ListNode &link_list, int val){
    Node *p = link_list->next;
    while(NULL != p){
        if(p->data == val) return p;
        p = p->next;
    }
    return NULL;
}

void InsertRear(ListNode &link_list, int val){
    Node *p = link_list;
    while(NULL != p->next){
        p = p->next;
    }
    p->next = new Node(val, p);
}

void InsertInside(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list;
    while(NULL != p->next){
        if(count == index){
            Node *temp = new Node(val, p); //新节点的前驱指针指向p
            temp->next = p->next; //新节点的后继指针指向后一个节点
            p->next->pre = temp; //后继节点的前驱指针指向新节点
            p->next = temp; //前驱节点的后继指针指向新节点
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"插入失败"<<endl;
}

void ChangeNode(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }
    while(NULL != p->next){
        if(count == index){
            p->data = val;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"修改失败"<<endl;
}

void RemoveRear(ListNode &link_list){
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }else if(NULL == p->next){
        delete p;
        link_list->next = NULL;
    }
    while(NULL != p->next->next){
        p = p->next;
    }
    delete p->next;
    p->next = NULL;
}

void RemoveInside(ListNode &link_list, int index){

    Node *p = link_list;
    if(NULL == p->next){
        cout << "链表为空" << endl;
        return;
    }
    int count = 0;
    while(NULL != p->next->next){
        if(count == index){
            Node* temp = p->next->next; //得到后继节点
            temp->pre = p; //修改后继节点的前驱指针
            delete p->next; //删除节点
            p->next = temp; //修改前驱节点的后继指针
            return;
        }
        p = p->next;
        count++;
    }
    cout << "index 超出索引" << endl;
}


int main(void){

    ListNode link_list = new Node();

    vector<int> a = {1,2,3,4,5};
    CreateList(link_list, a, a.size());
    Node *p = link_list->next->next;
    cout<<p->pre->data<<endl;
    ShowList(link_list);

    InsertInside(link_list, 0, 100);
    ShowList(link_list);

    InsertInside(link_list, 6, 100);
    ShowList(link_list);

    InsertRear(link_list, 100);
    ShowList(link_list);

    InsertInside(link_list, 2, 100);
    ShowList(link_list);

    RemoveRear(link_list);
    ShowList(link_list);

    RemoveInside(link_list, 6);
    ShowList(link_list);

    Node *temp = FindNode(link_list, 100);
    cout << temp->data << endl;

    ChangeNode(link_list, 0, 1000);
    ShowList(link_list);

    system("pause");
    return 0;
}
addict_jun
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++数据结构之链表
yao____yao的专栏
04-11 337
C++数据结构------链表       typedef int T;       struct Node{       T data;        Node* next;        Node(const T& d=T()):data(d),next(NULL){} }; class List{           Node* head; }; 经典insert&&
数据结构双向链表C++实现
Clown_pan的博客
05-22 818
#include <iostream> #include <stdio.h> #include <stdlib.h> #define OVERFLOW -3 #define true 1 #define false 0 #define ok 1 #define error -1 using namespace std; typedef struct DuLNo...
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
数据结构-双向链表(c++)超全超详细
热门推荐
Abieai的博客
12-01 1万+
文章目录前言一、双向链表是什么？二、双向链表上的基本操作1.定义双向链表2.初始化双链表3.前插法创建双链表4.尾插法创建双链表5.双向链表的遍历输出6.双链表的指定位置插入7.双链表的按位取值8.双链表的任意位置删除9.双链表的销毁三、全部代码(主函数部分比较凌乱）总结 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入，删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 提示：以.
双向链表详解及C++实现
最新发布
Weirdo的博客
06-15 424
本文详细介绍了双向链表的基本结构、操作实现以及C++代码示例。双向链表通过引入两个指针（prev和next）来实现对前后节点的访问，从而在插入、删除和遍历等操作上提供了更高的灵活性。在实际应用中，双向链表常用于需要频繁进行节点插入和删除的场景，如LRU（最近最少使用）缓存淘汰算法等。通过掌握双向链表的基本原理和实现方法，读者可以更好地理解和应用这种数据结构。
C++ 数据结构之-双向链表(link_list)
who_I_am__的博客
09-28 1052
双向链表（Doubly Linked List）是一种常见的数据结构，它与单向链表相似，但每个节点有两个指针，一个指向前一个节点（前驱节点），一个指向后一个节点（后继节点）。前向和后向遍历：由于每个节点都有前驱和后继指针，双向链表可以从头节点或尾节点开始，沿着不同的方向遍历整个链表。维护复杂性：因为每个节点有两个指针，所以在插入、删除或修改节点时，需要同时更新相关节点的前驱和后继指针，这增加了链表的维护复杂性。4、bool contains(T t) const // 判断元素t是否在list中。
使用C++实现双链表
qq_58240448的博客
07-01 3095
c++实现的双链表
C++实现双向链表（含迭代器）
m0_51797936的博客
04-30 1624
C++实现双向链表（含迭代器）1.什么是双向链表2.双向链表的C++代码实现(1)数据节点的代码编写(2)迭代器(3)链表初始化(4)获取节点(5)插入和删除节点（6）链表的交换与合并3.完整代码4.简单的测试代码 1.什么是双向链表 这里既然要实现双向链表，就首先要知道双向链表是什么。 双向链表，实际上就是一种储存数据的容器，是属于链表的其中一种。他的特点是：数据储存在不连续的内存空间中，每个数据节点包含 数据、上一个数据节点的指针和下一个数据节点的指针。 缘于他的这种特点，他可以在 O(1)O(1)O(
C++数据结构--双向链表
海到无边天作岸 山登绝顶我为峰
04-07 2202
测试代码 #include <iostream> #include <iomanip> using namespace std; template <class DataType> struct DulNode { DataType data; DulNode <DataType>*prior,*next; }; template <cla...
C++实现双链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-04 2554
双链表节点由存储的数据、指向前一个元素的指针和指向后一个元素的指针构成，因此双联表节点的代码也很容易得到，如下： 双链表和单链表类似，也需要添加、删除和查找。 1、插入操作 插入的情况说明：插入每次都在第一个位置插入，也就是在伪头节点（不含元素）后插入。插入节点的过程：插入的代码逻辑： 2、删除操作 将目标节点的下一个节点的指针指向目标节点的前一个节点（目标节点下一个节点不存在则省略） 将目标节点的前一个节点的指针指向目标节点的下一个节点 代码逻辑： 3、查找操作 不同于单链表，双链表查找直接返回目
双向链表C++
alanmian的博客
11-06 3389
双向链表，顾名思义，一条可双向进行的就叫双向链表。那怎么搞？也就是有前驱跟后继，有些时候有人不明白什么是前驱跟后继啊，浅显的讲讲，前驱就是当前结点指向上一个结点的箭头，那么上一个结点就是当前结点的前驱，后继就是当前结点的前一个结点，从上一个结点指向当前结点就叫后继，也就是说上个结点作为头，那当前结点作为尾，头的后继不就是尾嘛。 然后有头尾指针，双向嘛。头指针运动，尾指针也运动，所以这里要多存个尾指针。那说了这么多，先来构造给双向链表吧。 定义结构体老掉牙的东西了 思路！： 1.刚前面说了有前驱跟后继，那么
双向循环链表（C++实现）
st66688的博客
09-22 2795
双向循环链表内容整理
C++容器——双向链表（list）
shouhu010的博客
03-15 1003
是一个容器，其结构为双向链表，支持从任何位置插入和删除元素，但不支持快速的随机访问，空间效率较低；与forward_list相比，该容器提供了双向迭代功能；
C++双向链表
King逍灬遥
11-30 689
C++双向链表 双向链表顾名思义就是每个结点具有两个指针，一个指向前一个结点，一个指向后一个结点，我们不必拘束与单链表的创建遍历操作等，这样大大减少了使用中存在的效率问题。 在单链表中，我们有一个数据域还有一个指针域，数据域用来存储相关数据，而指针域负责链表之间的“联系”，双向链表具有两个指针域，一个负责向后连接，一个负责向前连接。 //单链表结构 template<class ...
双向链表实现(c/c++)
qq_52095705的博客
11-16 2190
前言 数据结构还是得来一手。 一.关于链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表通过指针域能把多个元素串联起来。 一般的链表中每个元素只有一个指向下一个元素的指针域，而我们的双向链表却有两个指针域，其中一个指针域指向下一个元素，另一个指针域指向这个元素的上一个元素。 接下来看程序
C++实现双向链表
qq_33373460的博客
04-29 2611
list.h #pragma once #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; typedef struct DNode { struct DNode *prior; //前结点指针域 ElemType data; //数据域 struct DNode *next; //后结点指针域 }DNode, *DLinkL
C/C++数据结构——双链表
qq_63883017的博客
11-17 644
注：如果现在你身边没有纸和笔建议你不要往下看，学数据结构更多需要的不是编码能力，而是数学能力，如果你只靠看不动手画，原本很简单的数据结构，可能会让你怀疑人生，导致学不下去！！！该篇文章是继上一篇文章数据结构之单链表如果没有看过前一篇文章建议先把那篇文章看了再看这里，不然可能看不懂，还有就是，上一篇说的单向不带头节点，所以我在上一篇提到的头节点指的是第一个节点***，而我在***这篇文章中提到的所有头节点都是指的标兵位（也有叫哨兵位的），和上一篇中说的不是一个东西，希望大家别搞混了。数据结构——单链表。
利用C++实现双向链表的基本操作
weixin_43165699的博客
07-25 4124
本文采用利用C++实现了对双向链表的基本操作。操作包括：双向链表的构建、链表指定位置的插入、链表指定位置的删除、链表长度的获取、链表指定位置元素的获得及指定元素位置的获得、整体链表的删除。
C++实现双链表（Double Linked List）
weixin_42133358的博客
05-14 1607
C++实现双链表（Double Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 双链表与单链表相同，都是由结点（Node）组成，但结点结构有所不同，结点中有一个数据域和两个指针域，数据域存放结点中的数据，一个指针域指向下一个结点的地址，另一个指针指向上一个结点的地
单链表与双向链表详解：数据结构必备
链表是数据结构中的一个重要概念，它允许元素以非线性方式存储，每个元素由一个数据域和一个或多个指针链接在一起，形成节点。本文主要讨论的是单链表和双向链表，它们是两种常见的线性数据结构。 单链表是一种简单...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值