【数据结构--双链表】

已于 2022-10-25 21:22:41 修改
阅读量3.2k 收藏 29
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表 list c语言
于 2022-05-04 00:49:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61719813/article/details/124564698
版权

文章目录

双向链表

双向链表的定义

什么是双向链表？

双向链表顾名思义，就是链表由单向的链变成了双向链。双向链表(double linked list)是在单链表的每个结点中再设置一个指向其前驱结点的指针域。

非空带头结点的双向链表

在这里插入图片描述

双向链表的存储结构

//双链表节点结构体
typedef struct DoubleLinkNode
{
    char data;
    struct DoubleLinkNode* prior;
    struct DoubleLinkNode* next;
} Node,*NodePtr;

双向链表的初始化

//初始化
NodePtr initLinkList()
{
    NodePtr LinkHeader = (NodePtr)malloc(sizeof(Node));
    LinkHeader->data = '\0';
    LinkHeader->next = NULL;
    LinkHeader->prior = NULL;
    Linklength = 0;
    return LinkHeader;
}

双向链表的插入

双向链表的插入其实并不复杂，不过顺序很重要，千万不能写反了。

我们假设存储e的节点为q，要实现将结点q插入到结点p和p -> next之间需要下面几步，如下图所示。

在这里插入图片描述
顺序是先搞定q的前驱和后继，再搞定后结点的前驱，最后解决前结点的后继

代码如下：

//在某位置插入
void ListInsert(NodePtr LinkHeader, int InsertPosition, char InsertChar)
{
    if(InsertPosition < 0 || InsertPosition > Linklength)
    {
        printf("The position %d out of range of linked list!\n",InsertPosition);
        return ;
    }
    NodePtr p,q,r,tail;
    p = LinkHeader;
    for(int i = 0; i < InsertPosition; ++i)
    {
        p = p->next;
        if(!p)
        {
            printf("The position %d out of range of linked list!\n",InsertPosition);
            return ;
        }
    }
    q = (NodePtr)malloc(sizeof(Node));
    q->data = InsertChar;
    r = p->next;
    q->prior = p;
    q->next = r;
    p->next = q;
    if(r)
    {
        r->prior = q;
    }
    Linklength++;
}

双向链表的删除

如果插入操作理解了，那么删除操作就比较简单了。

若要删除节点q，只需要下面两个步骤，如下图所示。
在这里插入图片描述

代码如下：

//删除第Position个节点
void ListDeleteByPosition(NodePtr LinkHeader, int Position)
{
    NodePtr p,q,r,tail;
    int j = 0;
    tail = tailNodeSearch(LinkHeader);
    p = LinkHeader;
    while(p->next && j < Position)
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || j > Position)
    {
        printf("Can't delete it!\n");
        return ;
    }
    q = p->next;
    r = q->next;
    p->next = r;
    if(r)
    {
        r->prior = p;
    }
    free(q);
    Linklength--;
}

//删除第一个数据域为x的节点
void ListDeleteByData(NodePtr LinkHeader, char DeleteChar)
{
    NodePtr p,q,r;
    p = LinkHeader;
    while(p->next && p->next->data != DeleteChar)
    {
        p = p->next;
    }
    if(!(p->next))
    {
        printf("The char '%c' does't exist.\n",DeleteChar);
        return ;
    }
    q = p->next;
    r = q->next;
    p->next = r;
    if(r)
    {
        r->prior = p;
    }
    free(q);
    Linklength--;
}

寻找尾结点

双向链表与单链表不同的是单链表只能单向读取，双向链表可以双向读取，因此在反向打印时，需要先找到尾结点

//寻找尾节点
NodePtr tailNodeSearch(NodePtr LinkHeader)
{
    NodePtr p = LinkHeader;
    while(p->next)
    {
        p = p->next;
    }
    return p;
}

正向打印

//正向打印
void printListByHead(NodePtr LinkHeader)
{
    NodePtr p = LinkHeader->next;
    while (p)
    {
        printf("%c",p->data);
        p = p->next;
    }
    printf("\n");
}

反向打印

//反向打印
void printListByTail(NodePtr LinkHeader)
{
    NodePtr tail = tailNodeSearch(LinkHeader);
    NodePtr p = tail;
    while (p)
    {
        printf("%c",p->data);
        p = p->prior;
    }
    printf("\n");
}

链表节点的读取

双链表除了有一个指向下一结点的指针外，还有一个指向前一结点的指针，可以双向遍历，故双链表的在查找时可利用二分法的思想去实现，那么这样效率就会大大提高。

//链表节点的读取（打印链表中第position个数据元素的值）
void GetElement(NodePtr LinkHeader, int position)
{
    NodePtr p,q,r;
    if(position <= Linklength/2)
    {
        p = LinkHeader->next;
        int j = 0;
        while(p && j < position)
        {
            p = p->next;
            ++j;
        }
        if(!p || j > position)
        {
            printf("Can't get it !\n");
            return ;
        }
        printf("The element at its %d-th position is %c\n",position,p->data);
    }else
    {
        p = tailNodeSearch(LinkHeader);
        int j = 0;
        while(p->prior && j < Linklength-position-1)
        {
            p = p->prior;
            ++j;
        }
        if(!p || j > Linklength-position-1)
        {
            printf("Can't get it !\n");
            return ;
        }
        printf("The element at its %d-th position is %c\n",position,p->data);
    }
}

测试运行截图

在这里插入图片描述

完整代码

#include <stdio.h>
#include <stdlib.h>
int Linklength;

//双链表节点结构体
typedef struct DoubleLinkNode
{
    char data;
    struct DoubleLinkNode* prior;
    struct DoubleLinkNode* next;
} Node,*NodePtr;

//初始化
NodePtr initLinkList()
{
    NodePtr LinkHeader = (NodePtr)malloc(sizeof(Node));
    LinkHeader->data = '\0';
    LinkHeader->next = NULL;
    LinkHeader->prior = NULL;
    Linklength = 0;
    return LinkHeader;
}

//寻找尾节点
NodePtr tailNodeSearch(NodePtr LinkHeader)
{
    NodePtr p = LinkHeader;
    while(p->next)
    {
        p = p->next;
    }
    return p;
}

//正向打印
void printListByHead(NodePtr LinkHeader)
{
    NodePtr p = LinkHeader->next;
    while (p)
    {
        printf("%c",p->data);
        p = p->next;
    }
    printf("\n");
}

//反向打印
void printListByTail(NodePtr LinkHeader)
{
    NodePtr tail = tailNodeSearch(LinkHeader);
    NodePtr p = tail;
    while (p)
    {
        printf("%c",p->data);
        p = p->prior;
    }
    printf("\n");
}

//在某位置插入
void ListInsert(NodePtr LinkHeader, int InsertPosition, char InsertChar)
{
    if(InsertPosition < 0 || InsertPosition > Linklength)
    {
        printf("The position %d out of range of linked list!\n",InsertPosition);
        return ;
    }
    NodePtr p,q,r,tail;
    p = LinkHeader;
    for(int i = 0; i < InsertPosition; ++i)
    {
        p = p->next;
        if(!p)
        {
            printf("The position %d out of range of linked list!\n",InsertPosition);
            return ;
        }
    }
    q = (NodePtr)malloc(sizeof(Node));
    q->data = InsertChar;
    r = p->next;
    q->prior = p;
    q->next = r;
    p->next = q;
    if(r)
    {
        r->prior = q;
    }
    Linklength++;
}

//删除第一个数据域为x的节点
void ListDeleteByData(NodePtr LinkHeader, char DeleteChar)
{
    NodePtr p,q,r;
    p = LinkHeader;
    while(p->next && p->next->data != DeleteChar)
    {
        p = p->next;
    }
    if(!(p->next))
    {
        printf("The char '%c' does't exist.\n",DeleteChar);
        return ;
    }
    q = p->next;
    r = q->next;
    p->next = r;
    if(r)
    {
        r->prior = p;
    }
    free(q);
    Linklength--;
}

//删除第Position个节点
void ListDeleteByPosition(NodePtr LinkHeader, int Position)
{
    NodePtr p,q,r,tail;
    int j = 0;
    tail = tailNodeSearch(LinkHeader);
    p = LinkHeader;
    while(p->next && j < Position)
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || j > Position)
    {
        printf("Can't delete it!\n");
        return ;
    }
    q = p->next;
    r = q->next;
    p->next = r;
    if(r)
    {
        r->prior = p;
    }
    free(q);
    Linklength--;
}

//链表节点的读取（打印链表中第position个数据元素的值）
void GetElement(NodePtr LinkHeader, int position)
{
    NodePtr p,q,r;
    if(position <= Linklength/2)
    {
        p = LinkHeader->next;
        int j = 0;
        while(p && j < position)
        {
            p = p->next;
            ++j;
        }
        if(!p || j > position)
        {
            printf("Can't get it !\n");
            return ;
        }
        printf("The element at its %d-th position is %c\n",position,p->data);
    }else
    {
        p = tailNodeSearch(LinkHeader);
        int j = 0;
        while(p->prior && j < Linklength-position-1)
        {
            p = p->prior;
            ++j;
        }
        if(!p || j > Linklength-position-1)
        {
            printf("Can't get it !\n");
            return ;
        }
        printf("The element at its %d-th position is %c\n",position,p->data);
    }
}

//测试
void insertDeleteTest()
{
    printf("---------------Initialize bidirectional linked list--------------\n");
    NodePtr tempList = initLinkList();
    printListByHead(tempList);
    printListByTail(tempList);

    printf("---------------Inserts a node at the specified location--------------\n");
    ListInsert(tempList,0,'H');
    ListInsert(tempList,1,'e');
    ListInsert(tempList,2,'l');
    ListInsert(tempList,3,'l');
    ListInsert(tempList,4,'o');
    
    printListByHead(tempList);
    printListByTail(tempList);

    printf("---------------Gets the node data field at the specified location--------------\n");
    GetElement(tempList,0);
    GetElement(tempList,4);
    GetElement(tempList,5);

    printf("---------------Delete the first node whose data field is X--------------\n");
    ListDeleteByData(tempList,'e');
    printListByHead(tempList);
    printListByTail(tempList);

    printf("---------------Delete the position node--------------\n");
    ListDeleteByPosition(tempList,3);
    printListByHead(tempList);
    printListByTail(tempList);
}

int main()
{
    insertDeleteTest();
}

总结

双向链表相当于单链表来说，要复杂一些，对于插入和删除要格外小心。另外它由于每个结点都需要记录两份指针，所以在空间上的占用要略微多一些，说白了就是用空间换取时间。

双链表在查找时，我们可以借用二分法的思路，从head（首节点）向后查找操作和last（尾节点）向前查找操作同步进行，这样双链表的效率可以提高一倍。

黎子想写好代码
关注
  • 5
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数据结构的双链表算法
09-27
数据结构的双链表算法：双链表基本运算插入前插入后，循环双链表的基本运算。用C++语言写的控制台程序。
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
双链表————详讲
2301_80687320的博客
02-09 998
上一篇文章，我们简单了解了顺序表和单链表；单链表在插入数据时，我们处理前后关系时非常复杂，我们无法通过一个节点找到上一个节点位置，而本篇文章所说的双链表将可以解决这一问题。双链表只是结构复杂，然后我们在查找，插入链接都非常简单，只需要把结构搭建起来就可以了。
【数据结构】双链表详解
weixin_60371270的博客
11-08 1011
主要介绍了双向带头循环链表的节点的定义和接口函数的实现，以及该链表于单链表的优点和注意事项。
【数据结构】双链表---超详解
2201_75806908的博客
10-14 387
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的；简单来说，线性表的链式存储结构生成的表，称作“链表”。（线性表顾名思义就是像线一样连接起来的表，需要注意的是这里所说的表是一种数据结构，而不是平时我们所说的表格），例如单链表是不是就像一条线一样把他们连接起来，至于什么叫做链式的存储结构详细看下面的介绍，这就是一个链表，且是链表中的单链表。//定义类型}LTNode;
数据结构-双向链表
04-14
完整双向链表的实现代码，包括了线性表的基本操作:插入、删除、访问和查找
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 5940
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
【数据结构】双向链表
m0_73648729的博客
06-28 4468
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3030
双向链表
双向链表详解
m0_74859835的博客
06-02 2521
顾名思义，就是在头节点之前插入一个节点，并将其变成头节点。2. 看下标是不是头节点，尾节点，是的话直接调用头插法，尾插法。2. 判断是不是头节点，如果是且不只有一个元素。1. 要先判断他输入的下标合不合法。遍历链表 - 将所有值置为空。1. 先找到key所在的位置。
数据结构-双链表.c
10-16
数据结构-双链表.c
链表-使用PHP实现的双向链表数据结构.zip
03-13
链表 链表_使用PHP实现的双向链表数据结构
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构--双链表的操作
03-09
数据结构--双链表的操作---带头节点
数据结构七：线性表之链式栈的设计
weixin_47040031的博客
04-27 792
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
2201_75475240的博客
04-27 1254
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
数据结构 ： 树的分类及在数据库索引中的运用
simensk的博客
04-27 887
树 数据库索引 b树 b+树
acwing算法提高之数据结构--可持久化数据结构
最新发布
YMWM_的博客
04-30 210
acwing算法提高之数据结构--可持久化数据结构
双链表
05-26
双链表(Double Linked List)是一种数据结构，它与单链表类似，但每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。双链表可以从前往后遍历，也可以从后往前遍历，因为每个节点都有前驱和后继节点的指针。 双链表的优点是可以在常数时间内在任意位置插入或删除节点，而无需移动其他节点。但是，双链表相对于单链表需要更多的空间来存储指针，因此在空间有限的情况下，可能不是最优的选择。 下面是一个简单的双链表的示例代码： ``` class Node: def __init__(self, data): self.data = data self.prev = None self.next = None class DoubleLinkedList: def __init__(self): self.head = None self.tail = None self.size = 0 def add(self, data): new_node = Node(data) if self.head is None: self.head = new_node self.tail = new_node else: new_node.prev = self.tail self.tail.next = new_node self.tail = new_node self.size += 1 def remove(self, data): current = self.head while current is not None: if current.data == data: if current.prev is None: self.head = current.next else: current.prev.next = current.next if current.next is None: self.tail = current.prev else: current.next.prev = current.prev self.size -= 1 return True current = current.next return False ``` 在上面的代码中，我们定义了一个 `Node` 类来表示双链表中的每个节点，每个节点包含一个 `data` 属性和两个指针 `prev` 和 `next`，分别指向前一个节点和后一个节点。我们还定义了一个 `DoubleLinkedList` 类来管理双链表，它包含一个 `head` 指针和一个 `tail` 指针，分别指向双链表的头部和尾部。它还包含一个 `size` 属性来记录双链表的大小。 我们为 `DoubleLinkedList` 类添加了两个方法，`add` 和 `remove`。`add` 方法用于向双链表中添加一个新节点，它首先创建一个新的 `Node` 对象，然后根据当前的 `head` 和 `tail` 指针来确定新节点的位置，并更新相应的指针。最后，我们增加了 `size` 的值。 `remove` 方法用于从双链表中删除给定的 `data` 值的节点。它首先遍历整个链表，找到第一个 `data` 值与给定值相等的节点。然后，它检查这个节点是否是头节点或尾节点，并相应地更新 `head` 和 `tail` 指针。最后，我们减少 `size` 的值并返回 `True` 表示删除成功，如果没有找到相应的节点，则返回 `False`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

黎子想写好代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值