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++实现双向链表的基本操作
weixin_43165699的博客
07-25 4123
本文采用利用C++实现了对双向链表的基本操作。操作包括：双向链表的构建、链表指定位置的插入、链表指定位置的删除、链表长度的获取、链表指定位置元素的获得及指定元素位置的获得、整体链表的删除。
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++实现）
st66688的博客
09-22 2794
双向循环链表内容整理
双向链表详解及C++实现
最新发布
Weirdo的博客
06-15 416
本文详细介绍了双向链表的基本结构、操作实现以及C++代码示例。双向链表通过引入两个指针（prev和next）来实现对前后节点的访问，从而在插入、删除和遍历等操作上提供了更高的灵活性。在实际应用中，双向链表常用于需要频繁进行节点插入和删除的场景，如LRU（最近最少使用）缓存淘汰算法等。通过掌握双向链表的基本原理和实现方法，读者可以更好地理解和应用这种数据结构。
C++双向链表
King逍灬遥
11-30 688
C++双向链表 双向链表顾名思义就是每个结点具有两个指针，一个指向前一个结点，一个指向后一个结点，我们不必拘束与单链表的创建遍历操作等，这样大大减少了使用中存在的效率问题。 在单链表中，我们有一个数据域还有一个指针域，数据域用来存储相关数据，而指针域负责链表之间的“联系”，双向链表具有两个指针域，一个负责向后连接，一个负责向前连接。 //单链表结构 template<class ...
C/C++数据结构——双链表
qq_63883017的博客
11-17 644
注：如果现在你身边没有纸和笔建议你不要往下看，学数据结构更多需要的不是编码能力，而是数学能力，如果你只靠看不动手画，原本很简单的数据结构，可能会让你怀疑人生，导致学不下去！！！该篇文章是继上一篇文章数据结构之单链表如果没有看过前一篇文章建议先把那篇文章看了再看这里，不然可能看不懂，还有就是，上一篇说的单向不带头节点，所以我在上一篇提到的头节点指的是第一个节点***，而我在***这篇文章中提到的所有头节点都是指的标兵位（也有叫哨兵位的），和上一篇中说的不是一个东西，希望大家别搞混了。数据结构——单链表。
C/C++ 双链表之逆序的实例详解
01-01
C/C++ 双链表之逆序的实例详解 一、结点结构  双向链表的数据结构定义如下：  typedef struct node { ElemType data; struct node *prior struct node *next; }list;  其中，ElemType可以是任意数据类型...
C++ 模版双向链表的实现详解
09-05
C++ 模板双向链表是一种灵活的数据结构，它允许在链表的两端进行插入和删除操作。在本文中，我们将深入探讨如何在C++中实现一个模板化的双向链表，以及其主要功能。 首先，定义一个名为`double_linked`的类模板，它...
C++ 双链表的基本操作(详解)
08-31
在C++编程中，双链表是一种非常重要的数据结构，它允许我们高效地进行前后方向的遍历。本文将深入探讨C++实现双链表的基本操作，包括创建、打印、逆序打印、节点插入和删除等核心功能。 1. 双链表概念 双链表...
c++实现双向链表，类模板双向链表
热门推荐
hugang的博客
09-06 1万+
c++实现双向链表的思想和c很类似，不同的是c++是将实现的函数放在类中，这样就可以由类实例化出对象再调用类中的函数进行添加、删除、查找、插入元素等功能。类模板实现双向链表在最后进行说明和实现，方法依然类似。 c++实现双向链表 #include #include using namespace std; typedef int Datatype; typedef
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
数据结构之双链表
C2395850595的博客
05-03 1567
一、双链表的定义： 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 二、代码功能： 1、 ...
【C++学习笔记】数据结构与算法——设计双链表
qq_58517981的博客
09-10 70
head为虚拟头结点，head->next为第一个头结点。
【C++STL】双向循环链表与其迭代器的深度剖析及实现（百字短文速通）
qq_73216106的博客
02-08 1611
初学者学习笔记
c++实现双链表基本操作详解
qq_61607805的博客
01-27 1394
本人是来自双非本科的一只大一菜鸟，加入校队（我是吊车尾┭┮﹏┭┮）已有一个月的时间，现在开始写我的第一篇博客记录我的学习历程，废话不多说，如理解有误，请勘正。对于一个一无所有的空链表，我们用0,1来表示它的头结点与尾结点（为空集）。所以接下来进行初始化操作：
【C++实现双链表】
wddkxg的博客
03-02 193
学习双链表的结构、头插法建表、尾插法建表以及双链表的操作实现。 C++实现双链表
数据结构：顺序表，链表，双向链表
m0_61350245的博客
08-12 834
顺序表，链表，双向链表
双向链表
代码演奏家
11-10 158
前提 首先定义节点类型，是一个带头和尾的链表，头结点和尾节点都不存放数据，空链表时，他们首尾相连。 宏定义了需要存储的数据。 代码 #include <stdio.h> #include <stdlib.h> #define ElemType char typedef struct LNode{ ElemType data; struct LNode *prior; struct LNode *next; }*Link,*Position; typede

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值