浅谈【数据结构】链表之双链表

最新推荐文章于 2024-11-03 22:17:06 发布
最新推荐文章于 2024-11-03 22:17:06 发布
阅读量411 收藏 6
点赞数 9
分类专栏： 基础数据结构 文章标签： 链表 数据结构 c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67526434/article/details/141500093
版权

目录

1、删除结点

2、双向链表

2.1增加结点

2.2删除结点

谢谢帅气美丽且优秀的你看完我的文章还要点赞、收藏加关注

没错，说的就是你，不用再怀疑！！！

希望我的文章内容能对你有帮助，一起努力吧！！！

本文主要以图示+代码为主  

数据结构最多的操作：增删改查

1、删除结点

但是我们发现单链表存在一个弊端：不能回溯（没法直接回到前一个结点）

有木有方法可以解决这个问题？

双向链表它可以解决单向链表只有一个指针指向下一个结点没法回溯的这么一个问题。

2、双向链表

双向链表它包含数据域和指针域（但是指针域相对单链表而言多出了一个指针：prev指针）

struct node
{
// 数据域
    ElementType data;
// 指针域
    struct node *prev; // 前指针
    struct node *next; // 后指针
};

2.1增加结点

图示：

头插：

尾插：

中间位置插入：

2.2删除结点

图示：删除头结点  删除中间节点 删除尾结点    图示示例+代码示例

***双链表示例***

/*
    双向链表
*/
#include <iostream>
// 换一种方式来实现双向链表：对象

template <typename DataType>
class ddl
{
public:
    ddl(); // 创建一个双向链表
    ~ddl(); // 销毁一个双向链表

    // 增删改查

    // 增加
    bool addNode(DataType d)
    {
        // 中、头、尾插入...

        // 尾插法
        // 如果链表是空的那么需要将新节点作为第一个结点增加
        if(firstNode == nullptr)
        {
            firstNode = new struct node;
            firstNode->data = d;
            firstNode->next = nullptr;
            firstNode->prev = nullptr;
        }
        else
        {
            // 先找尾结点
            struct node *tail_ptr = firstNode;
            while(tail_ptr->next)tail_ptr = tail_ptr->next;

            // 进行插入
            struct node *newNode = new struct node;
            newNode->data = d;
            newNode->next = nullptr;
            newNode->prev = nullptr;
            tail_ptr->next = newNode;
            newNode->prev  = tail_ptr;
        }
        length ++;
        return true;
    }

    // 删除
    bool delNode(DataType d)
    {
        if(length == 0)
            return false;
        
        // 查找要删除的结点
        struct node *delNode_ptr = firstNode;
        while(delNode_ptr)
        {
            // 进行数据比较，是否尾需要删除的结点
            if(delNode_ptr->data == d)
            {
                // 进行删除
                // 需要判断一下是不是只有一个元素
                if(length == 1)
                {
                    // 断开当前结点的指向，让它脱离链表
                    firstNode->next = nullptr;
                    firstNode->prev = nullptr;
                    delete firstNode;
                    length -- ;
                    return true;
                }

                // 第一步：把前驱和后继的指向更新
                    // 更新前驱结点指向:让前驱结点的next指针指向当前结点的后继结点
                    // delNode_ptr 当前结点，delNode_ptr->prev 就是当前结点的前驱结点
                    if(delNode_ptr->prev != nullptr)
                        (delNode_ptr->prev)->next = (delNode_ptr->next);

                    // 更新后继结点的指向：让后继结点的prev指针指向当前结点的前驱结点
                    // delNode_ptr 当前结点，delNode_ptr->next 就是当前结点的后继结点
                    if(delNode_ptr->next != nullptr)
                        (delNode_ptr->next)->prev = (delNode_ptr->prev);

                // 第二步：断开当前结点的指向，让它脱离链表
                delNode_ptr->next = nullptr;
                delNode_ptr->prev = nullptr;

                // 第三步：释放当前结点的空间
                delete delNode_ptr;

                length -- ;
                return true;
            }

            // 更新指针
            delNode_ptr = delNode_ptr->next;
        }
        return false;
    }

    // 修改
    bool chgNode(DataType od,DataType nd)
    {
        if(length == 0)
        {
            std::cout << "修改失败：空的" << std::endl;
            return false;
        }

        // 查找需要修改的元素
        struct node *chgNode_ptr = firstNode;
        while(chgNode_ptr)
        {
            // 判断是不是需要修改的元素
            if(chgNode_ptr->data == od)
            {
                chgNode_ptr->data = nd;
                return true;
            }

            chgNode_ptr = chgNode_ptr->next;
        }
        std::cout << "修改失败：没有找到指定元素" << std::endl;
        return false;
    }

    // 查找
    bool srhNode(DataType d)
    {
        if(length == 0)
        {
            std::cout << "查找失败：空的" << std::endl;
            return false;
        }

        // 查找需要修改的元素
        struct node *srhNode_ptr = firstNode;
        while(srhNode_ptr)
        {
            // 判断是不是需要修改的元素
            if(srhNode_ptr->data == d)
                return true;

            srhNode_ptr = srhNode_ptr->next;
        }
        std::cout << "查找失败：没有找到指定元素" << std::endl;
        return false;
    }
    

    // 打印
    void prtList()
    {
        // for(int i = 0;i < length;i++)
        // {
        //     std::cout << node_ptr->data;
        //     node_ptr = node_ptr->next;
        // }

        struct node *node_ptr = firstNode;
        std::cout << "DoubleDirectionList( ";
        while(node_ptr)
        {
            std::cout << node_ptr->data << " ";
            node_ptr = node_ptr->next;
        }
        std::cout << ")"<<std::endl;
    }

private:

    // 首结点地址
    struct node
    {
        DataType data;
        struct node *prev;
        struct node *next;
    }*firstNode;

    // // 尾结点地址
    // struct node
    // {
    //     DataType data;
    //     struct node *prev;
    //     struct node *next;
    // }lastNode;

    // 统计一下个数
    int length;
};


template <typename DataType>
ddl<DataType>::ddl()
    : firstNode(nullptr)
    , length(0)
{
}

// 析构：用于销毁链表
template <typename DataType>
ddl<DataType>::~ddl()
{
    struct node *delNode_ptr = firstNode;
    while(delNode_ptr)
    {
        // 更新指针
        firstNode = firstNode->next;

        // 销毁结点
        delNode_ptr->next = nullptr;
        delNode_ptr->prev = nullptr;

        delete delNode_ptr;
        length--;
        delNode_ptr = firstNode;
    }
}


int main()
{
    ddl<int> d;
    d.addNode(10);
    d.addNode(11);
    d.addNode(13);

    d.prtList();

    d.chgNode(10,100);
    d.prtList();

    d.delNode(13);
    d.prtList();
    // d.delNode(13);
    // d.prtList();
    return 0;
}

***增删改查***

        

/*
    无头结点的单链表
*/

#include <iostream>

/*
    结点类型
*/
struct node
{
    // 用来存储数据的空间（成员）称为：数据域
    int data;       

    // 用来保存其他结点的地址（关系）称为：指针域
    struct node *next;
};



//----------------------------------------------------------增加----------------------------------------------------
/*
    @brief：头部插入
    @param: list 需要增加新数据的链表指针
    @param: data 是需要存入链表的数据
    @return : 链表首地址
*/
struct node* addNodeHead(struct node *list,int data)
{
    // list 表示就是一个链表（链表首地址/首结点的地址）头插法其实就是在它的首结点前面插入
    struct node *newNode = new struct node;
    newNode->data = data; // 数据存入结点数据域
    newNode->next = list; // 因为新结点作为新的首结点存入链表，那么原有的首结点就变成了新节点后继结点
    return newNode; // 返回newNode因为newNode变成了新的首结点了。更新链表的首地址
}

/*
    @brief: 尾部插入
    @param: list 需要增加新数据的链表指针
    @param: data 是需要存入链表的数据
    @return : 链表首地址
*/
struct node* addNodeTail(struct node *list,int data)
{
    struct node *newNode = new struct node;
    newNode->data = data; // 将通过键盘获取到的数据存入结构体的数据域中
    newNode->next = nullptr; // 因为它是一个新结点，暂时是没有后继结点

    // 搞一个临时指针，来指向首结点
    struct node *node_ptr = list;

    // 找尾结点
    while(node_ptr->next)node_ptr = node_ptr->next;
    
    // 到这个位置 node_ptr 此时指向的结点是尾结点
    // 就可以把newNode作为尾结点的后继结点添加到链表里面去了
    node_ptr->next = newNode;

    return list;
}

/*
    @brief : 中间插入法
    @param : list 需要增加数据的链表首地址
    @param : data 需要增加到链表的数据
    @return : 链表首地址
*/
struct node *addNodeMid(struct node *list,int data)
{
    struct node *newNode = new struct node;
    newNode->data = data; // 将通过键盘获取到的数据存入结构体的数据域中
    newNode->next = nullptr; // 因为它是一个新结点，暂时是没有后继结点

    // 循环比较数据 大到小  小到大
    // struct node *node_previce = nullptr;
    // struct node *node_current = list;

    // 第一种方法两个指针
    // while(node_current)
    // {
    //     if(node_current->data > data)
    //         break; // 找到插入位置了
        
    //     // 把两个指针往后移
    //     node_previce = node_current;
    //     node_current = node_current->next;
    // }

    // // 进行插入
    // if(node_previce == nullptr) // 说明需要作为首结点插入（头插入)
    // {
    //     // 头插代码
    // }
    // else
    // {
    //     // 直接插入到node_previce的后面
    //     newNode->next = node_previce->next; // 要成为node_previce下一个结点的前驱结点
    //     node_previce->next = newNode; // 然后让newNode成为node_previce的后继结点
    // }

    // 第二种方法提前判断
    struct node *node_ptr = list;
    // 如果第一个结点就比data大说明要插入到最前面（头插法）
    if(node_ptr->data > data)
    {
        // 头插法
        list = addNodeHead(list,data);
        return list;
    } 
    while(node_ptr&&node_ptr->next)
    {
        if(node_ptr->data < data && node_ptr->next->data >= data) // 大于前一个小于后一个
        {
            // 将新结点的next指向当前结点的后继结点node_ptr->next
            newNode->next = node_ptr->next;

            // 让newNode成为node_ptr的后继结点
            node_ptr->next = newNode;
            return list; // 退出增加
        }
        // 把指针往后移
        node_ptr = node_ptr->next;
    }

    // 严谨判断一下node_ptr->next是不是为空
    if(node_ptr->next == nullptr) // 尾插法
    {
        node_ptr->next = newNode;
    }

    return list;
}

//----------------------------------------------------------删除----------------------------------------------------
/*
    @brief:删除指定结点数据
    @param：list 需要删除元素的链表首地址
    @param：data 需要删除的那个元素的值
    @return : 链表首地址
*/
struct node *delNodeData(struct node*list,int data)
{
    // 严谨判断链表是否存在
    if(list == nullptr)
        return list;
    
    // 找需要删除的元素
    // 是不是首结点
    if(list->data == data)
    {
        // 第一步：获取后继结点指针
        struct node *newHeadNode = list->next;

        // 第二步：将需要删除的首结点的next置空
        list->next = nullptr; // 此时的它和链表没有关系了

        // 第三步：将list结点删除/释放
        delete list;

        // 第四步：返回新的首结点
        return newHeadNode;
    }

    // 不是首结点
    struct node *node_ptr = list;
    while(node_ptr->next) // 判断下一个的原因：是能够找到需要删除的元素的前一个，next才是实际要比对的结点
    { 
        // 找到那个结点了
        /*
            node_ptr: 表示需要删除的结点的前驱结点
            (node_ptr->next): 表示需要删除的结点
            (node_ptr->next)->data : 表示需要删除的结点的数据
        */

        if((node_ptr->next)->data == data)
        {
            // 第一步：获取需要删除的结点指针
            struct node*needDelNode = node_ptr->next;

            // 第二步：将前驱结点的next指向当前删除结点的next
            node_ptr->next = needDelNode->next;

            // 第三步：将当前删除结点的next置空
            needDelNode->next = nullptr;

            // 第四步：将当前删除结点进行释放
            delete needDelNode;

            // 第五步：返回结点首地址
            return list;
        }

        // 移动指针
        node_ptr = node_ptr->next;
    }

    // 为空退出：表示没找到啊
    return list;
}

//----------------------------------------------------------修改----------------------------------------------------
/*
    @brief:修改指定数据的结点
    @param：list 需要修改元素的链表首地址
    @param：oldData 需要修改的那个元素的值
    @param：newData 新数据
*/
void changeNodeData(struct node*list,int oldData,int newData)
{
    // 严谨判断链表是否存在
    if(list == nullptr)
    {
        std::cout << "链表为空" << std::endl; 
        return;
    }
       
    // 查找需要修改的数据是否存在
    while(list)
    {
        // 判断
        if(list->data == oldData)
        {
            list->data = newData;
            return;
        }

        // 移动指针
        list = list->next;
    }
    
    // 如果循环都结束了还没找到，那么就是没有这个数据
    std::cout << "链表不存在" << std::endl;
    return;
}

//----------------------------------------------------------查找----------------------------------------------------
/*
    @brief:修改指定数据的结点
    @param：list 需要查找元素的链表首地址
    @param：data 需要查找的那个元素的值
*/
void searchNodeData(struct node*list,int data)
{
    // 严谨判断链表是否存在
    if(list == nullptr)
    {
        std::cout << "链表为空" << std::endl; 
        return;
    }
       
    // 查找需要修改的数据是否存在
    while(list)
    {
        // 判断
        if(list->data == data)
        {
            std::cout << "找到链表" << std::endl;
            return;
        }

        // 移动指针
        list = list->next;
    }
    
    // 如果循环都结束了还没找到，那么就是没有这个数据
    std::cout << "链表不存在" << std::endl;
    return;
}


/*
    @brief:创建一个新链表
    @return:返回新链表的首结点的地址
*/
struct node *createNewList()
{
    // 新链表的首结点指针
    struct node *newList = nullptr;

    // 循环通过数据不断的去增加新结点到链表中
    while(1)
    {
        int data = -1;
        // 通过键盘获取数据
        std::cin >> data;

        // 判断退出条件
        if(data == -1)
            break;

        // 做第一次判断：链表中有没有结点
        if(newList == nullptr)
        {
            struct node *newNode = new struct node;
            newNode->data = data; // 将通过键盘获取到的数据存入结构体的数据域中
            newNode->next = nullptr; // 因为它是一个新结点，暂时是没有后继结点

            // 如果newList是nullptr说明该链表里面为空，当前的新节点就是首届点
            newList = newNode;
            continue;
        }

        // 通过中间插入法增加结点
        newList = addNodeMid(newList,data);

        // 通过尾插法增加结点
        // newList = addNodeTail(newList,data);
    }
    return newList;
}


/*
    @brief: 销毁一个链表
    @list : 需要销毁的链表
    @return : 销毁成功返回空指针
*/
struct node *destoryList(struct node *list)
{
    while(list)
    {
        // 保存当前结点的后继结点，以防等会找不到了
        struct node * next_node = list->next;

        // 将当前结点的next指针置空
        list->next = nullptr;

        // 释放当前结点
        delete list;

        // 移动下一个待删除结点
        list = next_node;
    }

    return list;
}


// 打印链表（遍历方法）
void printList(struct node *list)
{
    // 判断是不是空链表
    if(list == nullptr)
    {
        std::cout << "链表为空" << std::endl;
        return;
    }

    std::cout << "List( ";
    // 如果不为空打印链表元素
    while(list) // 只要list不为空就一直循环
    {
        // list本来就可以表示首结点
        std::cout << list->data << " ";

        // 让list移动到下一个结点
        list = list->next;
    }
    std::cout << ")" << std::endl;
}

int main()
{
    // 不在栈空间里面申请结点空间
    // 创建一个链表
    struct node *newList = createNewList();

    // 打印链表元素
    printList(newList); // 传入的值是newList存储的地址，并非newList自己的地址

    // 打印链表元素
    printList(newList); // 传入的值是newList存储的地址，并非newList自己的地址

    int data;
    std::cin >> data;

    // 销毁链表
    destoryList(newList);
    return 0;
}

超级飞侠12138
关注
专栏目录
【数据结构】浅谈数据结构-链表【思路+例题学习】
贤鱼的博客
10-31 850
数据结构--链表讲解
浅谈iOS 数据结构之链表
08-29
链表作为基础的数据结构之一，对于提升程序效率有显著作用。本文将深入探讨链表的概念，特别是单链表和双链表，并提供Objective-C实现的示例。 链表是一种数据结构，它由一系列节点组成，每个节点包含数据以及指向...
详解双链表
2301_79811033的博客
11-06 97
双向意味：该链表中的任何一个结点都可以访问其前面和后面的结点。要是现这个功能，则该链表中要有2个指针变量，一个。
浅谈【数据结构】链表之其他形态
weixin_67526434的博客
08-24 1083
浅谈【数据结构】链表之其他形态
浅谈:数据结构之双链表结构与代码模拟双链表的实现
fushuaiCSDN的博客
07-14 182
双链表 本文是观看尚硅谷韩老师数据结构与算法根据老师讲解自己做的笔记,部分信息收集网络 与单链表区别 逻辑上没有区别。他们均是完成线性表的内容。主要的区别是结构上的构造有所区别。 对于单链表： 对于一个节点，有储存数据的data。和next后驱节点(指针)。也就是这个单链表想要一些遍历的操作都得通过前节点—>后节点。 对于双链表： 对于一个节点，有些和单链表一样有存储数据的data,指向后方的next（指针）。它拥有单链表的所有操作和内容。但是他还有一个前驱节点pre(指针)。 双向链表应用实例
浅谈双向链表
wcqqq的博客
07-02 355
介绍双向链表的基础知识
浅谈数据结构之链表
倚栏静望的博客
11-09 409
单向链表是由节点组成的数据结构，每个节点包含数据和指向下一个节点的指针。链表的头节点指向第一个节点，而最后一个节点的指针指向空值（null）。双向链表是单向链表的扩展，每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针。这使得在双向链表中，可以在节点之间双向移动。循环链表是一种特殊形式的链表，其中最后一个节点的指针指向链表的头部，形成一个循环。这使得链表可以无限循环下去。链表是一种灵活的数据结构，有单向链表、双向链表和循环链表等多种形式。
浅谈单链表与双链表的区别
热门推荐
kangxidagege的博客
05-06 7万+
昨天面试官面试的时候问了我一道关于链表的问题：情境如下 面试官：请说一下链表跟数组的区别？ 我：数组静态分配内存，链表动态分配内存；数组在内存中连续，链表不连续；数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)；数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。 根据以上分析可得出数组和链表的优缺点如下：   数组的优点 随机访问性强（通过下标进行...
浅谈线性表——链表
m0_63191002的博客
08-25 857
链表(LinkedList)：将数据以链式形式进行存储。链表中的每一个元素称为节点(结点)，节点中由2部分组成，一部分存放数据元素，一部分存放下一个数据元素的地址。链表逻辑上是连续的，物理上不一定连续，是因为链表的连续性是通过地址连接起来，并不像顺序表那样是一段物理地址连续的存储单元依次存储数据元素。
【数据结构1.0】双向链表
X__cheng的博客
12-02 1000
ListNode;由上分析可知，该链表节点需要包含三个数据域，所以我们定义结构体，结构体成员data用来存储需存储数据、结构体成员next用来存储后一个节点地址、结构体成员prev用来存储前一个节点地址。至于为什么要把int重命名成LTDataType，那是因为如果需存储数据的类型如果有所变化的话，我们只需更改此处的int更改成需存储数据的类型即可，极大方便后续的代码维护。
浅谈PHP链表数据结构(单链表)
12-18
链表是一种重要的数据结构，它不同于数组，数组中的元素在内存中是连续存储的，而链表中的元素在内存中可以分散存储。链表的主要优势在于它的灵活性，它允许高效地插入和删除元素，因为这些操作只需要改变节点的引用...
Redis的数据结构
2302_81083129的博客
10-31 986
缓存穿透、缓存雪崩、缓存击穿、Redis的数据结构及常用命令
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 325
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
数据结构之树
最新发布
x6886_57的博客
11-03 465
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
[数据结构]堆
2401_83816455的博客
10-29 282
堆，本质是一颗完全二叉树。代码实现可参考树的代码。
高阶数据结构--图（graph）
2401_87257864的博客
10-31 1241
邻接顶点：在无向图中G中，若(u, v)是E(G)中的一条边，则称u和v互为邻接顶点，并称边(u,v)依附于顶点u和v；在有向图G中，若<u, v>是E(G)中的一条边，则称顶点u邻接到v，顶点v邻接自顶点u，并称边<u, v>与顶点u和顶点v相关联。E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫。是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)
数据结构-哈夫曼树
2303_80261633的博客
10-30 522
【代码】数据结构-哈夫曼树。
数据结构之线段树
zaishaoyi的专栏
11-01 229
的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。线段树是算法竞赛中常用的用来维护。
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值