数据结构之双向链表的实现

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

目录

一、双向线链表的原理

1.为什么要存在双向链表？

2.双向链表的结构

二、双向链表的实现

1.链表的定义

2.链表的初始化

3.链表的长度

4.获取指定元素e的位置

5.获取指定位置index的元素

6.插入指定位置的元素

7.删除指定位置的元素

8.清空链表

9.打印链表的中元素的值

三、打印测试功能

1.测试

2.结果输出

3.总代码

一、双向线链表的原理

        在上一节我们讲了数据结构之线性表（单链表的实现），这一节我们来讲解双向链表的实现，以及双向链表的优缺点。

1.为什么要存在双向链表？

        我们都知道每存在一种数据结构都是解决某项问题的。我们的单链表，总是从头到尾找结点，难道就不可以正反遍历都可以吗？当然可以，只不过需要加点东西而已。

        我们在单链表中，有了 next 指针，这就使得我们要查找下一结点的时间复杂度为 O(1)。可是如果我们要查找的是上一结点的话，那最坏的时间复杂度就是 O(n) 了，因为我们每次都要从头开始遍历查，所以就有了双向链表。

2.双向链表的结构

        如下图所示：双向链表（double linkedlist）是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。所以在双向链表中的结点都有两个指针域，一个指向直接后继，另 一个指向直接前驱。        

二、双向链表的实现

        双向链表是单链表中扩展出来的结构，所以它的很多操作是和单链表相同的，比如 求长度的 ListLength，查找元素的 GetElem，获得元素位置的 LocateElem 等，这 些操作都只要涉及一个方向的指针即可，另一指针多了也不能提供什么帮助。

1.链表的定义

         主要是定义一些功能常量和单链表的结构，和之前的数据结构的文章一样。代码如下：

#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;

typedef struct DuLNode
{
    struct DuLNode* prior;
    ElemType data;
    struct DuLNode* next;
}*DuLinkList;
2.链表的初始化

          这里链表的初始化我选择的是用户输入的形式，用户输入一个值就往链表添加一个用户输入的元素，当用户输入的值为 -1 时，代表用户输入结束。 

// 链表的初始化
DuLinkList InitList(DuLinkList L)
{
    int data, size;
    DuLinkList Last, p;
    L = (DuLinkList)malloc(sizeof(DuLNode));
    L->prior = NULL;
    L->next = NULL;
    Last = L;
    printf("请输入节点的值（输入-1表示输入完成）:\n");
    size = 0;
    printf("当前链表的大小为：%d\n",size);
    while (true)
    {
        if (scanf("%d", &data) != 1)break;
        if (data == -1)break;
        p = (DuLinkList)malloc(sizeof(DuLNode));
        if (p == NULL)
        {
            printf("内存不足！\n");
            break;
        }
        p->data = data;
        p->prior = Last;
        p->next = NULL;

        Last->next = p;
        Last = p;
    }
    Last->next = NULL;
    return L;
}
3.链表的长度

        求链表的长度和单链表相同，设置一个变量  length++ ，然后 while 遍历，最后返回 length。 

// 链表的长度
int ListLength(DuLinkList L)
{
    int length = 0;
    if (L == NULL) return length;
    if (L->next == NULL) return length;
    while (L->next)
    {
        L = L->next;
        length++;
    }
    return length;
}
4.获取指定元素e的位置

        不断用while遍历链表，当有data 与 e 相同时，打印当前 index。

// 获取指定元素的位置
int GetElem(DuLinkList L, ElemType e)
{
    int found = 0;
    int index = 1;
    if (L == NULL) return ERROR;
    if (L->next == NULL) return ERROR;
    L = L->next;
    do
    {
        if (L->data == e)
        {
            printf("找到一个节点，位置在%d\n", index);
            found = 1;
        }
        L = L->next;
        index++;
    } while (L != NULL);
    if (found == 0)
    {
        printf("指定位置的元素一个都没有找到\n");
        return ERROR;
    }
    return OK;
}
5.获取指定位置index的元素

        定义一个变量，进行index操作，判断是否与指定位置 i 相同，获取其节点值。

// 根据位置获取元素
int GetElembyIndex(DuLinkList L, int index, ElemType* e)
{
    int i = 0;
    if (L == NULL || L->next == NULL || index < 1) return ERROR;
    while (L->next && i < index)
    {
        L = L->next;
        i++;
    }
    if (i == index)
    {
        *e = L->data;
        return OK;
    }
    return ERROR;
}
6.插入指定位置的元素

        和单链表操作几乎一样，就是多了一个指针域的赋值。    

// 插入链表
Status ListInsert(DuLinkList* L, int i, ElemType e)
{
    DuLinkList inserted, temp;
    int index = 1;
    int length = ListLength(*L);
    if ((*L == NULL) || (i > length + 1) || (i <= 0)) return ERROR;
    temp = *L;

    while (temp->next != NULL && index < i)
    {  
        temp = temp->next;
        index++;
    }

    inserted = (DuLinkList)malloc(sizeof(DuLNode));
    inserted->data = e;
    inserted->next = temp->next;
    inserted->prior = temp;

    temp->next = inserted;
    if (temp->next) temp->next->prior = inserted;
    return OK;
}
7.删除指定位置的元素

        如图所示。

// 删除指定位置链表
Status ListDelete(DuLinkList* L, int i, ElemType* e)
{
    int length = ListLength(*L);
    int index = 0;
    if (i <= 0 || L == NULL || (*L)->next == NULL || i > length) return ERROR;
    DuLinkList temp = *L;
    while (temp->next != NULL && index < i)
    {
        temp = temp->next;
        index++;
    }
    temp->prior->next = temp->next;
    if (temp->next)
    {
        temp->next->prior = temp->prior;
    } 
    *e = temp->data;
    free(temp);
    return OK;
}
8.清空链表

        链表的清空操作。

// 清空链表
void ListClear(DuLinkList* L)
{
    DuLinkList p, q;
    p = (*L)->next;

    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
}
9.打印链表的中元素的值

         功能比较简单，通过不断遍历打印其节点的data值。

// 打印链表
void print(DuLinkList L)
{
    if (L == NULL || L->next == NULL)
    {
        printf("链表为空！！\n");
        return;
    }
    int index = 0;
    while (L->next)
    {
        if (index > 0)
        {
            printf("->");
        }
        L = L->next;
        printf("%d", L->data);
        index = 1;
    }
    printf("\n");
}

三、打印测试功能

1.测试

        测试主要为测试以上的功能是否可以实现。

void test()
{
    ElemType e;
    int index;
    DuLinkList L{};
    L = InitList(L);
    printf("双链表的长度：%d\n", ListLength(L));
    print(L);

    printf("请输入想要知道的第几个位置上的元素:");
    scanf("%d", &index);
    GetElembyIndex(L, index, &e);
    printf("该位置上的数字为：%d\n", e);

    printf("请输入想知道某个元素在哪个位置上：");
    scanf("%d", &e);
    GetElem(L, e);


    printf("请输入你想在第几个位置上插入元素：");
    scanf("%d", &index);
    printf("请输入你想插入元素的值：");
    scanf("%d", &e);
    ListInsert(&L, index, e);
    print(L);

    printf("输入你想删除元素的位置：");
    scanf("%d", &index);
    ListDelete(&L, index, &e);
    printf("删除元素的值为：%d\n", e);
    print(L);

    printf("清空列表\r\n");
    ListClear(&L);
    printf("列表的长度为：%d\n", ListLength(L));
}
2.结果输出

         结果输出如图所示：

3.总代码

        总代码如下：

#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;

typedef struct DuLNode
{
    struct DuLNode* prior;
    ElemType data;
    struct DuLNode* next;
}*DuLinkList;

// 链表的初始化
DuLinkList InitList(DuLinkList L)
{
    int data, size;
    DuLinkList Last, p;
    L = (DuLinkList)malloc(sizeof(DuLNode));
    L->prior = NULL;
    L->next = NULL;
    Last = L;
    printf("请输入节点的值（输入-1表示输入完成）:\n");
    size = 0;
    printf("当前链表的大小为：%d\n",size);
    while (true)
    {
        if (scanf("%d", &data) != 1)break;
        if (data == -1)break;
        p = (DuLinkList)malloc(sizeof(DuLNode));
        if (p == NULL)
        {
            printf("内存不足！\n");
            break;
        }
        p->data = data;
        p->prior = Last;
        p->next = NULL;

        Last->next = p;
        Last = p;
    }
    Last->next = NULL;
    return L;
}

// 链表的长度
int ListLength(DuLinkList L)
{
    int length = 0;
    if (L == NULL) return length;
    if (L->next == NULL) return length;
    while (L->next)
    {
        L = L->next;
        length++;
    }
    return length;
}

// 获取指定元素的位置
int GetElem(DuLinkList L, ElemType e)
{
    int found = 0;
    int index = 1;
    if (L == NULL) return ERROR;
    if (L->next == NULL) return ERROR;
    L = L->next;
    do
    {
        if (L->data == e)
        {
            printf("找到一个节点，位置在%d\n", index);
            found = 1;
        }
        L = L->next;
        index++;
    } while (L != NULL);
    if (found == 0)
    {
        printf("指定位置的元素一个都没有找到\n");
        return ERROR;
    }
    return OK;
}

// 根据位置获取元素
int GetElembyIndex(DuLinkList L, int index, ElemType* e)
{
    int i = 0;
    if (L == NULL || L->next == NULL || index < 1) return ERROR;
    while (L->next && i < index)
    {
        L = L->next;
        i++;
    }
    if (i == index)
    {
        *e = L->data;
        return OK;
    }
    return ERROR;
}

// 插入链表
Status ListInsert(DuLinkList* L, int i, ElemType e)
{
    DuLinkList inserted, temp;
    int index = 1;
    int length = ListLength(*L);
    if ((*L == NULL) || (i > length + 1) || (i <= 0)) return ERROR;
    temp = *L;

    while (temp->next != NULL && index < i)
    {  
        temp = temp->next;
        index++;
    }

    inserted = (DuLinkList)malloc(sizeof(DuLNode));
    inserted->data = e;
    inserted->next = temp->next;
    inserted->prior = temp;

    temp->next = inserted;
    if (temp->next) temp->next->prior = inserted;
    return OK;
}

// 删除指定位置链表
Status ListDelete(DuLinkList* L, int i, ElemType* e)
{
    int length = ListLength(*L);
    int index = 0;
    if (i <= 0 || L == NULL || (*L)->next == NULL || i > length) return ERROR;
    DuLinkList temp = *L;
    while (temp->next != NULL && index < i)
    {
        temp = temp->next;
        index++;
    }
    temp->prior->next = temp->next;
    if (temp->next)
    {
        temp->next->prior = temp->prior;
    } 
    *e = temp->data;
    free(temp);
    return OK;
}

// 清空链表
void ListClear(DuLinkList* L)
{
    DuLinkList p, q;
    p = (*L)->next;

    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
}

// 打印链表
void print(DuLinkList L)
{
    if (L == NULL || L->next == NULL)
    {
        printf("链表为空！！\n");
        return;
    }
    int index = 0;
    while (L->next)
    {
        if (index > 0)
        {
            printf("->");
        }
        L = L->next;
        printf("%d", L->data);
        index = 1;
    }
    printf("\n");
}


void test()
{
    ElemType e;
    int index;
    DuLinkList L{};
    L = InitList(L);
    printf("双链表的长度：%d\n", ListLength(L));
    print(L);

    printf("请输入想要知道的第几个位置上的元素:");
    scanf("%d", &index);
    GetElembyIndex(L, index, &e);
    printf("该位置上的数字为：%d\n", e);

    printf("请输入想知道某个元素在哪个位置上：");
    scanf("%d", &e);
    GetElem(L, e);


    printf("请输入你想在第几个位置上插入元素：");
    scanf("%d", &index);
    printf("请输入你想插入元素的值：");
    scanf("%d", &e);
    ListInsert(&L, index, e);
    print(L);

    printf("输入你想删除元素的位置：");
    scanf("%d", &index);
    ListDelete(&L, index, &e);
    printf("删除元素的值为：%d\n", e);
    print(L);

    printf("清空列表\r\n");
    ListClear(&L);
    printf("列表的长度为：%d\n", ListLength(L));
}
int main()
{
    test();
    return 0;
}
大卫的纯爱战士
关注
数据结构之双向链表详解
小源_ 的博客
12-20 3604
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
数据结构——双向链表的实现
2301_79998744的博客
04-14 548
双向链表的实现——C语言版
【数据结构】双向链表实现
m0_73367097的博客
03-26 1716
双向链表的定义与实现
数据结构——双向链表
麦麦的博客
03-11 2307
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
【数据结构与算法】之双向链表及其实现！
2301_80221228的博客
04-16 2037
​。
【数据结构】双向链表的实现
adcxhw的博客
04-07 1424
又是一篇万字文章，建议收藏。
数据结构--双向链表
m0_62706197的博客
06-24 1053
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
Java数据结构之双向链表
qq15035899256的博客
07-05 1856
双向遍历，既可以从前向后遍历，也可以从后往前遍历。(工作中常用) 优点：可以找到前驱和后继，可进可退；缺点：增加删除节点复杂，需要多分配一个指针存储空间。
数据结构：双向链表
2401_86551514的博客
08-03 1068
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3777
双向链表
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
数据结构-5.2.树的性质
最新发布
ADCvbV的博客
10-12 238
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
数据结构之顺序表——静态顺序表(C语言版)
努力码字中······
10-09 1191
首先我们来介绍一下顺序表的概念：线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 579
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
栈的操作算法实现（数据结构）
m0_61903191的博客
10-09 381
验证性实验内容：编写一个程序sqstack.cpp,实现顺序栈(假设栈中元素类型ElemType为char的各种基本运算，并在此基础上设计一个程序exp3-1.cpp。验证性实验：实现顺序栈各种基本运算的算法掌握栈的存储结构的表示和实现方法。目的：领会顺序栈存储结构和掌握顺序栈中各种基本运算算法设计。(3)依次进栈元素a、b、c、d、e。(2)判断栈s是否非空。(4)判断栈s是否非空。(6)判断栈s是否非空。(5)输出出栈序列。
数据结构-八大排序之堆排序
m0_75163045的博客
10-08 598
原理：1. 利用完全二叉树构建大顶堆2. 堆顶元素和堆底元素进行交换，除堆底元素之外其余元素继续构建大顶堆3. 重复2，直到所有元素都不参与构建 整个数组排序完成完全二叉树：数据从上到下，从左到右排列大顶堆：父节点的值大于或等于其左右孩子的值堆顶元素和堆底元素进行交换数组的形式：完全二叉树：arr [ i ] 的左孩子 arr [ 2i+1 ]arr [ i ] 的右孩子 arr [ 2i+2 ]arr [ i ] 的父节点 arr [ (i-1) / 2 ]大顶堆：arr [ i ] >=
双向链表实现与频度操作
"这篇代码实现了一个简单的双向链表数据结构，并包含了对链表的基本操作，如初始化、清除、销毁、检查是否为空以及获取链表长度。同时，链表节点中包含了一个`freq`字段，用于记录元素的频度。" 在数据结构中，双向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大卫的纯爱战士

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

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

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

打赏作者

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

抵扣说明：

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

余额充值