CPP实现双链表

最新推荐文章于 2024-05-15 00:23:47 发布
最新推荐文章于 2024-05-15 00:23:47 发布
阅读量143 收藏
点赞数
文章标签： 数据结构 算法 c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bananas_3/article/details/128619853
版权

双链表

今天我们来实现一个双链表

首先,理清结构体成员,关于结构体的命名,在当前数据结构中视为局部变量,但是为了混合编程时候的区分,我更倾向于见名知义

遵循简单明了的原则,我们叫节点为DLNode,即Double-linked List Node.

数据组成

  • 前驱节点指针
  • 数据成员
  • 后继节点指针
typedef int ElemType;
typedef struct DLNode
{
    DLNode *precursor;
    ElemType data;
    DLNode *successor;
} DLNode;

初始化

自此我们规定,在数据结构的初始化中,尽量单独定义方法去申请内存和初始化数据

使用引用形参,开辟空间然后设置指针指向为空即可

在这里,我们学习一个新的方法,可以省去我们手动置空的操作,void *calloc(size_t nitems, size_t size)会设置分配的内存为零

  • nitems – 要被分配的元素个数。
  • size – 元素的大小。
void Init(DLNode *&DL)
{
    DL = (DLNode *)calloc(1, sizeof(DLNode));
}

创建

首先是头插法,插入节点的操作顺序一般为(将待插入节点称为t,待插入位置的节点称为DL):

  1. t.data写入数据
  2. t后继指针指向DL的后继指针
  3. t前驱指针指向DL
  4. DL的后继指针指向t

忽然间想到了需要修改尾结点的前驱指针,然后就想到了需要判断尾结点是否为空,但是这里是创建,第一个尾结点是我们的临时节点,不可能为空,所以就不用考虑空节点的前驱问题了,这个问题是在指定位置插入时需要考虑的

void HeadInsertionCteate(DLNode *&DL)
{
    DLNode *tempNode;

    ElemType data;
    scanf("%d", &data);
    while (data != 0)
    {
        tempNode = (DLNode *)calloc(1, sizeof(DLNode));
        tempNode->data = data;
        tempNode->successor = DL->successor;
        tempNode->precursor = DL;

        DL->successor = tempNode;
        // 头插法头结点的后继已经被初始化为空,所以省去插入的判断
        // if (tempNode->successor != NULL)
        // {
        //     //或许这里的逻辑用在插入方法里面更合适
        //     tempNode->successor->precursor = tempNode;
        // }
        scanf("%d", &data);
    }
}

然后是尾插法,需要一个保持指向尾结点的游标节点

void TailInsertionCreate(DLNode *&DL)
{
    DLNode *tempNode;
    DLNode *tailCursor = DL; // 始终指向尾结点
    int data;
    scanf("%d", &data);
    while (data != 0)
    {
        tempNode = (DLNode *)calloc(1, sizeof(DLNode));

        tempNode->data = data;

        tailCursor->successor = tempNode;
        tempNode->precursor = tailCursor;
        tailCursor = tempNode;

        scanf("%d", &data);
    }
    // 由于是calloc方法申请内存,所以不用在此置空尾游标后继指针了
}

增加

向指定位置添加节点,那么我们不妨先去写根据位置获取节点的方法

插入的思路很简单,找到节点位置,然后有顺序的变更指向

  • 使用影子节点操作内存
  • 单链表不用判断尾结点是因为没有访问前驱,如果对空地址访问前驱则会出错
bool InsertByPosition(DLNode *DL, int position, ElemType data)
{
    DLNode *shadowNode = GetByPosition(DL, position);
    if (shadowNode == NULL) // 我还是没能实现追加,也许本来就不需要?
    {
        return false;
    }
    DLNode *tempNode = (DLNode *)calloc(1, sizeof(DLNode));
    tempNode->data = data;

    tempNode->successor = shadowNode;
    tempNode->precursor = shadowNode->precursor;
    tempNode->precursor->successor = tempNode;
    if (shadowNode->successor != NULL) // 需要这个判断,如果捕捉到的是尾部节点的话
    {
        tempNode->successor->precursor = tempNode;
        // 单链表不需要做这个判断,是因为不用获取前驱
    }
    return true;
}

删除

根据位置删除节点,通过我们定义查找方法,省去了做位置和合法性的判断

删除逻辑也是变更指向,需要做尾结点的判断,防止访问出错

bool DeleteByPosition(DLNode *DL, int position)
{
    DLNode *designatedNode = GetByPosition(DL, position);
    if (designatedNode == NULL)
    {
        return false;
    }
    designatedNode->precursor->successor = designatedNode->successor; // 尾结点也行
    if (designatedNode->successor != NULL)                            // 需要尾结点判断,尾结点之后的节点并不存在,也不存在前驱指针
    {
        designatedNode->successor->precursor = designatedNode->precursor;
    }
    return true;
}

修改

获取指定位置的节点,修改其中数据即可

bool UpdateByPosition(DLNode *DL, int position, ElemType data)
{
    DLNode *toBeUpdate = GetByPosition(DL, position);

    if (toBeUpdate == NULL)
    {
        return false;
    }
    toBeUpdate->data = data;
    return true;
}

查找

为了方便其他方法的使用,我们先来实现根据位置查找节点

需要判断位置的合法性

在循环里,使用严格不等号与自增运算相配合,小于的情况时,数据偏移,那么不满足时刚好为等于的情况,此时跳出循环即可

DLNode *GetByPosition(DLNode *DL, int position)
{
    if (position < 0)
    {
        return NULL;
    }
    if (position == 0)
    {
        return DL;
    }
    int cursor = 1;     // 以上已经省去0索引
    DL = DL->successor; // 忽略头结点
    while (DL != NULL)
    {
        if (cursor < position)
        {
            DL = DL->successor;
            cursor += 1;
        }
        else
        {
            // 现在是cursor==position的时候,返回即可
            break;
        }
    }
    return DL;
}

这里的根据值查找也会有好几种,在这里我们只设计从前往后遍历

bool IsExist(DLNode *DL, ElemType data)
{

    DL = DL->successor; // 忽略头结点
    while (DL != NULL)
    {
        if (DL->data == data)
        {
            return true;
        }
        DL = DL->successor;
    }
    return false;
}

代码

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

/*定义结构体*/
typedef int ElemType;
typedef struct DLNode
{
    DLNode *precursor;
    ElemType data;
    DLNode *successor;
} DLNode;

void Init(DLNode *&DL)
{
    DL = (DLNode *)calloc(1, sizeof(DLNode));
}

void HeadInsertionCteate(DLNode *&DL)
{
    DLNode *tempNode;

    ElemType data;
    scanf("%d", &data);
    while (data != 0)
    {
        tempNode = (DLNode *)calloc(1, sizeof(DLNode));
        tempNode->data = data;
        tempNode->successor = DL->successor;
        tempNode->precursor = DL;

        DL->successor = tempNode;
        // 头插法头结点的后继已经被初始化为空,所以省去插入的判断
        // if (tempNode->successor != NULL)
        // {
        //     //或许这里的逻辑用在插入方法里面更合适
        //     tempNode->successor->precursor = tempNode;
        // }
        scanf("%d", &data);
    }
}

void TailInsertionCreate(DLNode *&DL)
{
    DLNode *tempNode;
    DLNode *tailCursor = DL; // 始终指向尾结点
    int data;
    scanf("%d", &data);
    while (data != 0)
    {
        tempNode = (DLNode *)calloc(1, sizeof(DLNode));

        tempNode->data = data;

        tailCursor->successor = tempNode;
        tempNode->precursor = tailCursor;
        tailCursor = tempNode;

        scanf("%d", &data);
    }
    // 由于是calloc方法申请内存,所以不用在此置空尾游标后继指针了
}

DLNode *GetByPosition(DLNode *DL, int position)
{
    if (position < 0)
    {
        return NULL;
    }
    if (position == 0)
    {
        return DL;
    }
    int cursor = 1;     // 以上已经省去0索引
    DL = DL->successor; // 忽略头结点
    while (DL != NULL)
    {
        if (cursor < position)
        {
            DL = DL->successor;
            cursor += 1;
        }
        else
        {
            // 现在是cursor==position的时候,返回即可
            break;
        }
    }
    return DL;
}

bool InsertByPosition(DLNode *DL, int position, ElemType data)
{
    DLNode *shadowNode = GetByPosition(DL, position);
    if (shadowNode == NULL) // 我还是没能实现追加,也许本来就不需要?
    {
        return false;
    }
    DLNode *tempNode = (DLNode *)calloc(1, sizeof(DLNode));
    tempNode->data = data;

    tempNode->successor = shadowNode;
    tempNode->precursor = shadowNode->precursor;
    tempNode->precursor->successor = tempNode;
    if (shadowNode->successor != NULL) // 需要这个判断,如果捕捉到的是尾部节点的话
    {
        tempNode->successor->precursor = tempNode;
        // 单链表不需要做这个判断,是因为不用获取前驱
    }
    return true;
}

bool DeleteByPosition(DLNode *DL, int position)
{
    DLNode *designatedNode = GetByPosition(DL, position);
    if (designatedNode == NULL)
    {
        return false;
    }
    designatedNode->precursor->successor = designatedNode->successor; // 尾结点也行
    if (designatedNode->successor != NULL)                            // 需要尾结点判断,尾结点之后的节点并不存在,也不存在前驱指针
    {
        designatedNode->successor->precursor = designatedNode->precursor;
    }
    return true;
}

bool UpdateByPosition(DLNode *DL, int position, ElemType data)
{
    DLNode *toBeUpdate = GetByPosition(DL, position);

    if (toBeUpdate == NULL)
    {
        return false;
    }
    toBeUpdate->data = data;
    return true;
}

bool IsExist(DLNode *DL, ElemType data)
{

    DL = DL->successor; // 忽略头结点
    while (DL != NULL)
    {
        if (DL->data == data)
        {
            return true;
        }
        DL = DL->successor;
    }
    return false;
}

void Print(DLNode *DL)
{
    DL = DL->successor; // 忽略头结点
    while (DL != NULL)
    {
        printf("%2d\t", DL->data);
        DL = DL->successor;
    }
    printf("\n");
}
int main()
{
    DLNode *DL;
    Init(DL);
    // HeadInsertionCteate(DL);
    TailInsertionCreate(DL);
    Print(DL);
    /*查找*/
    DLNode *temp = GetByPosition(DL, 2);
    if (temp != NULL)
    {
        printf("get position 2 success data is %d\n", temp->data);
    }
    else
    {
        printf("get error\n");
    }
    /*查找2*/
    if (IsExist(DL, 888))
    {
        printf("data = 888 is exist\n");
        Print(DL);
    }
    else
    {
        printf("not exist\n");
    }
    /*插入*/
    if (InsertByPosition(DL, 2, 999))
    {
        printf("insert into position 2 data 999 success\n");
        Print(DL);
    }
    else
    {
        printf("insert fault\n");
    }
    /*删除*/
    if (DeleteByPosition(DL, 3))
    {
        printf("delete from position 3 success\n");
        Print(DL);
    }
    else
    {
        printf("delete fault\n");
    }
    /*修改*/
    if (UpdateByPosition(DL, 3, 888))
    {
        printf("update data = 888 on position 3 success\n");
        Print(DL);
    }
    else
    {
        printf("update fault\n");
    }
}
野生哈利嘎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
（C语言版）链表（三）——实现双向链表创建、删除、插入、释放内存等简单操作
菜鸟学C/C++
02-23 3万+
上午写了下单向循环链表的程序，今天下午我把双向链表的程序写完了。其实双向链表和单向链表也是有很多相似的地方的，听名字可以猜到，每个节点都包含两个指针，一个指针指向上一个节点，一个指针指向下一个节点。这里有两个特殊的地方，第一就是头节点的一个指针指向NULL空指针（没有前驱节点），第二就是尾节点的一个指针指向NULL指针（没有后继节点）。 我们可以看下双向链表的示意图（自己画的比较难看）：
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4622
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
从零开始的Cpp（2）STL容器：链表list与匿名函数lambda
m0_69248655的博客
10-03 181
list是一个双向链表，可以在任意位置高效地进行元素插入和删除操作。它不支持随机访问，只能通过迭代器进行顺序访问。插入和删除操作对于任意位置的元素都是高效的，不会导致重新分配内存。2.list的主要功能通过一段代码展示list的主要功能在上面的示例中，我们首先创建了一个空的list容器 `myList`。然后，我们使用 `push_back` 和 `push_front` 方法在尾部和头部插入元素。
链表CPP简单示例
最新发布
雪剑封心
05-15 196
链表根据指定位置添加元素。链表根据指定位置删除元素。
cpp单链表
m0_67016633的博客
12-15 356
伪头结点单链表实现方法，即用a[0]作为一个固定的头结点。对于没有固定头结点的单链表实现方法。基于cpp的面向对象设计。
C++链表的基本操作（初始化，头插法，插入，删除，输出）
热门推荐
FightingCSH的博客
11-13 1万+
1.初始化链表： 在定义初始化链表时，重新定义了一个头结点（Node* head = new Node），但已经在class LinkList时，创建过head，故再次创建会出现冲突 2.头插法创建链表： 使用头插法的时间复杂度是O(1)，而使用尾插法，时间复杂度是O(n)。因为头插法只需要一直从head找即可，但尾插法则需要遍历。下面给出头插法的思维构图： 3.插入节点： 只需使用一个Node* tmp来记录当前结点和后继节点的地址，...
C++ 实现双向链表的实例
08-30
C++ 实现双向链表的实例 本文将详细介绍 C++ 实现双向链表的实例的相关知识点，包括双向链表的概念、实现方法、代码分析等。 双向链表的概念 双向链表是一种特殊的链表结构，它允许在链表中插入、删除节点，并且...
数据结构的双链表算法
09-27
在C++中实现双链表，通常会定义一个结构体（或类）来表示链表节点，包括数据域和两个指针域。同时，还需要提供一个链表类，包含对链表的操作方法如插入、删除、遍历等。这些方法可能需要通过迭代或递归的方式来完成...
C++实现双向链表
08-19
本文将详细介绍如何使用C++实现一个双向链表，并提供相关的操作方法。 首先，我们定义一个结构体`ListNode`来表示链表中的节点。每个`ListNode`对象都有三个成员变量： 1. `ListNode* _next`：存储指向下一个节点...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
双向链表通讯录实现.cpp
06-01
用c++实现，添加备注，容易看懂，就一个代码，用双向链表实现通讯录，双向链表通讯录实现，数据结构的一个作业
单向链表.cpp 单向链表实现 包括类定义与测试
12-02
单向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 作者Clifford A.Shaffer 重庆大学使用教材
单链表.cpp
03-10
C语言数据结构单链表代码学习笔记，可以下载jiaoliuyixia
CPP中链表代码
08-26
CPP中链表代码
c语言简单实现双向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-18 2613
c语言最简单实现双向链表
【C++】 双向链表.cpp
weixin_34268169的博客
03-05 169
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表，因为双向链表解决了单向链表的不足和问题，而单链表因为出现的问题多，所以在面试中经常会考到单链表的问题。在这里，我用 .cpp对双向链表的基本操作进行实现。具体代码如下： L...
c++双链表
与其在害怕丢脸,不如在旅途中尽情地丢脸
05-26 315
test.cpp// dlist.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <iostream> #include "dlist.h"int main() { Dlist<int> dlist; int i = dlist.size(); std::cout << i << std::endl; dlist.
C++: 实现双向链表(例题讲解)
linwh8的博客
03-24 8985
C++: 实现双向链表(例题讲解)标签： C++ 双向链表by 小威威这一周的实验题比较水，我就不总结了，而作业题中最有意思的就是实现双向链表这一道题。这道题和我们之前做的单向链表是同一种类型的，只是这一次是双向链表，需要实现的操作较多，可能产生的bug也比之前多。我个人觉得，打出这道题的代码不难，难是难在调试。(入门链表的可以参照我以前的一篇文档入门：链表的基本操作)题目如下：(Author:
CPP一个链表，数据的增删改查（不包括翻转、排序，合并等）等，Node* &的使用
kuenking111的专栏
05-05 487
#include #include #include #include #include using namespace std; //typedef int T; //struct Node //{ // T data; // Node *next; // Node(const T& d) :data(d), next(NULL){} // operator T
链式存储的栈双向链表实现
08-05
链式存储的栈可以通过双向链表来实现。双向链表是一种数据结构，其中每个节点都包含一个指向前驱节点和后继节点的指针。栈是一种具有后进先出（LIFO）特性的数据结构，可以在链表的头部进行插入和删除操作。 下面是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值