双链表——双链表的定义及其基本操作（初始化、头插法尾插法建表、插入、查找、删除等）

于 2024-04-01 00:25:27 发布
阅读量1.3k 收藏 45
点赞数 54
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wanghh520max/article/details/137211508
版权

引言

由于单链表的缺点是无法快速地在给定节点之前插入或删除节点，因为无法直接访问前一个节点，需要从头开始遍历链表找到前一个节点。这样的操作效率较低。

524e90b04da64d89817743f56d447eac.png

所以我们引入双链表的主要目的是解决单链表的这个缺点。双链表中的每个节点除了指向下一个节点的指针外，还有指向前一个节点的指针。这样在双链表中可以快速地在给定节点之前或之后插入或删除节点，因为可以直接访问前一个节点和后一个节点。这样可以提高插入和删除操作的效率。

c549054ac58448a2b52018d26afe26ed.png

双链表的定义

双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。 

typedef struct DNode {
    Elemtype data;            //数据域
    struct DNode *prior;      //前驱指针
    struct DNode *next;       //后驱指针
} *DLinkList;

双链表的基本操作 

一、初始化

双链表与单链表一样，为了操作方便也可以加入头结点，那么初始化双链表其实就是定义一个头结点，然后将指针域置空。只不过双链表需要将前驱指针和后驱指针都置空。

d0fafeb3a3704baa9a19a78dc1b2ac62.png

void InitDLinkList(DLinkList L){
    //创建一个头结点
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));

    p->prior = NULL;    //头结点的前驱永远都是NULL
    p->next = NULL;     
}

二、插入操作

在双链表中p所指的结点之后插入结点s，其指针的变化过程如下图所示：

f8760ddf35e34cc59acd41785166e0fc.png

思路分析：

  1. 将s的next指针指向p的next指针所指的结点，即s的next指针指向p后继结点。
  2. 将s的prior指针指向p，即s的prior指针指向p所指的结点。
  3. 将p的next指针指向s，即p的next指针指向s。
  4. 将p后继结点的prior指针指向s，即p后继结点的prior指针指向s。

若p是最后一个结点，则p后继结点的prior指针指向s操作不需要，因为此时p->next = NULL.

代码实现：

//在p结点之后插入结点s
DLinkList InsertNewNode(DLinkList L) {
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p = L;    
    int j = 0;
    

    int pos;
    printf("请输入需要插入新结点的位置：");
    scanf("%d", &pos);

    while (j < pos - 1 && p != NULL) { //遍历到site - 1结点处
        p = p->next;
        j++;
    }
  
    //创建需要插入的结点s
    DLinkList s = (DLinkList) malloc(sizeof(DLinkList));
    printf("请输人需要插入的结点：");
    scanf("%d", &s->data);

    s->next = p->next;
    p->next->prior = s;
    p->next = s;
    s->prior = p;

    return p;
}

例：在双链表{10,30,40,50}中第一个结点后添加数据域为20的新结点，则插入操作完成之后的链表应为{10,20,30,40,50}

33c93387434f48ddb1304f3f58507320.png

三、建立双链表

双链表的建立同样也有两种方法，分别为头插法和尾插法。

1.头插法

对于每个元素，创建一个新结点，并将其插入到头结点之后，使新结点成为新的头结点。

最后创建成功的双链表的顺序和输入的顺序相反，即为逆序的。

头插法的时间复杂度为O(1)。

代码实现：

//利用头插法创建双链表
DLinkList Init_DLinkList_head() {
    //创建一个头结点
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p->prior = NULL;    //头结点的前驱永远都是NULL
    p->next = NULL;
    int length = 0;     记录双链表的长度
    int val = -1;

    while (true) {
        printf("请输入要插入链表的元素：");
        scanf("%d", &val);
        if (val == -1)    //输入结束的标志
            break;
        
        //创建新的结点
        DLinkList s = (DLinkList) malloc(sizeof(DLinkList));
        s->data = val;        //将元素输入到新结点的数据域中

        s->next = p->next;
        s->prior = p;
        p->next = s;
        length++;
    }
    printf("链表的长度为：%d\n", length);
    return p;
}

例：输入元素的顺序为10,20,30,40,50;则创建的链表应为{50,40,30,20,10}

8b598cca5eec40bebbf9ff33f38aca0f.png

2.尾插法

对于每个元素，创建一个新结点，并将其插入到头结点之后的尾部，更新尾结点的next指针和新结点的prior指针。遍历完成后，返回头结点的next指针，即为新链表的头结点。

尾插法的时间复杂度为O(n)，因为需要遍历整个双链表找到尾节点。

代码实现：

//利用尾插法创建双链表
DLinkList Init_DLinkList_tail() {
    DLinkList head = (DLinkList) malloc(sizeof(DLinkList));
    head->prior = NULL;
    head->next = NULL;

    int val = -1;
    int length = 0;

    //创建尾结点
    DLinkList ptr = (DLinkList) malloc(sizeof(DLinkList));
    ptr = head;        //初始状态下头结点和尾结点相同

    while (true) {
        printf("请输入要插入链表的元素：");
        scanf("%d", &val);
        if (val == -1)        // 输入结束的标志
            break;


        DLinkList s = (DLinkList) malloc(sizeof(DLinkList));
        s->data = val;
        s->next = NULL;    //将新结点的后驱结点置空，目的是保证尾部结点后驱结点始终为NULL

        ptr->next = s;
        s->prior = ptr;
        ptr = s;            //更新尾部结点
        length++;
    }
    printf("链表的长度为：%d\n", length);
    return head;
}

例： 输入元素的顺序为10,20,30,40,50;则创建的链表应为{10,20,30,40,50}

9327e306fee741d7b884e3f21994dea7.png

针对于上述两种方法可以根据具体需求选择使用：

        头插法适用于需要频繁插入操作的场景；

        尾插法适用于需要保持顺序的场景。

四、查找操作

双链表的查找分为按值查找和按位查找。

1.按值查找

此种方法无需用到前驱指针，所以查找方法和单链表的查找一样，可以类比学习。

基本思路：从双链表中的第一个结点出发，顺时针next域逐个往下搜索，直到找到第i个结点为止，否则返回最后一个结点指针域NULL。

平均时间复杂度：O(n)

代码实现：

//按值查找
void SearchList_value(DLinkList L) {
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p = L->next;    //从头结点下一个结点开始
    int j = 1;
    int value;
    printf("请输入需要查找的值：");
    scanf("%d", &value);

    while (p != NULL && p->data != value) {
        p = p->next;
        j++;
    }

    //如果p结点变为空了则说明还是没有目标元素值
    if(p == NULL){
        printf("没有找到目标元素！\n");
        return;
    }
    printf("元素%d是链表中第%d位元素。\n", value, j);
}

成功查找到目标元素

85da0ad229a74285919acf937e9b50b1.png

查找失败！

9d341dfc0ff84967bb5015cc3496de24.png

2.按位查找

从头节点开始，依次访问每个节点，直到找到目标位置的节点。

如果目标位置是第 i 个节点，需要访问 i−1 次 next 指针，或者访问n−i 次 prior 指针（n 为链表长度）。

 按位查找的时间复杂度为 O(n)

代码实现：

//按位查找
void SearchList_position(DLinkList L) {
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p = L->next;    //从头结点下一个结点开始
    int j = 1;
    int pos;
    printf("请输入需要查找结点的位置：");
    scanf("%d", &pos);

    while (p != NULL && j < pos) {
        p = p->next;
        j++;
    }
    if (p == NULL) {
        printf("没有找到目标结点！\n");
        return;
    }
    printf("第%d位结点的元素是%d\n", pos, p->data);
}

 成功查找到目标位置元素！

b271438423eb42ab9ceb0bde2159f8fd.png

查找失败！

cb25b74084d54044a657023dcbd57933.png

 思考

对于链表长度很大的双链表，在使用按位查找位序较为靠后的元素时我们还可以考虑从尾结点开始查找，因为双链表可以通过前驱指针找到上一个结点，这个是单链表所没有的。虽然首先会遍历到双链表的尾部然后再从尾部开始查找，那么可能会疑问这个首先还要遍历到尾部，这个消耗的时间是不是更长？其实不然，链表遍历的时间是很短的，相较于每个结点的查找遍历的时间性价比很高。

如果从尾结点开始查找的位置是 k，而链表的长度为 n，那么从头结点开始查找的位置就是 n−k−1。

五、删除操作

双链表删除结点时，只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可。

405695258537404b8a840db72acecee2.png

代码实现：

//删除结点操作
void DeleteNode(DLinkList L) {
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p = L;  //指向头指针
    int j = 0;

    int site;
    printf("请输入需要删除结点的位置：");
    scanf("%d", &site);

    while (p != NULL && j < site - 1) {
        p = p->next;
        j++;
    }

    if (NULL == p) {
        printf("要删除的结点超过链表的长度！\n");
        return;
    }

    DLinkList s = (DLinkList) malloc(sizeof(DLinkList));
    s = p->next; // 存储要删除的结点
    int num = s->data;

    DLinkList q = (DLinkList) malloc(sizeof(DLinkList));
    q = s->next;  //q指向要删除的结点下一个结点
    
    //将要删除的结点从双链表中摘除
    q->prior = p;
    p->next = q;

    free(s);      // 释放被删除结点的空间

    printf("删除的结点数据为：%d\n", num);
}

 成功删除操作

485c1fcfb81242d281c59676a99ca46d.png

删除失败！

 5f49a6224682422d8935a68aaf172326.png

六、遍历打印链表操作

 从单链表的第一个结点开始，依次遍历输出结点的数据直到最后一个结点。

代码实现：

//遍历并打印双链表
void PrintDLinkList(DLinkList L) {
    int i;
    DLinkList p = (DLinkList) malloc(sizeof(DLinkList));
    p = L->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
}

c121db32fb2d402a82503c06ecb7a9fd.png

总结 

单链表：

  • 单链表中的每个节点包含一个数据元素和一个指向下一个节点的指针。
  • 单链表只能从头结点开始依次遍历到尾节点，不能直接访问前一个节点。
  • 删除节点时，需要找到待删除节点的前一个节点，进行指针调整。
  • 插入节点时，只需要调整指针即可。
  • 单链表相对于双链表占用的内存空间更小。

双链表：

  • 双链表中的每个节点包含一个数据元素，一个指向前一个节点的指针和一个指向下一个节点的指针。
  • 双链表可以从头结点或尾节点开始遍历，也可以直接访问前一个节点。
  • 删除节点时，不需要找到待删除节点的前一个节点，可以直接根据前后指针进行删除。
  • 插入节点时，需要调整前后指针。
  • 双链表相对于单链表占用的内存空间更大，因为每个节点需要存储额外的指针。

总的来说，单链表适合在内存空间有限的情况下使用，而双链表适合需要频繁进行节点的插入和删除操作的情况下使用。选择使用哪种链表取决于具体的应用场景和需求。

 

Sunday_pro
关注
  • 54
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表的初始化删除及其插入操作
10-20
双向链表的初始化删除及其插入操作,欢迎大家下载
数据结构链表【头插法】【尾插法】【双向链表】
weixin_40989362的博客
08-06 5747
我们最近学了数据结构链表中的尾插法，头插法，双向链表 链表的步骤 1.申请一个新的节点空间 2.给新的节点赋值信息域 3.修改这个节点的指针域，将节点连接起来 尾插法：顾名思义就是从节点的尾部进行插入，首先申请一个节点空间，给新的节点赋值信息域，然后修改这个 节点的指针域，写链表首先要判断头节点是否为空，第一步，如果节点为空，将新的节点地址复制给头节点，如果头节点 不为空，要定义一个尾节点。专门来...
双链表的创建尾插法
m0_62591999的博客
08-21 213
C++尾插法双链表的创建
双链表——双链表的定义及其基本操作（初始化、头插法尾插法建表、插入、查找、删除、判空等）
热门推荐
薛定谔的猫的博客
04-18 2万+
文章目录双链表的定义双链表上的操作初始化插入操作建立双链表头插法建立双链表尾插法建立双链表遍历操作求双链表的长度查找操作按值查找按位查找删除操作判空操作完整代码及实例总结 双链表的定义  为什么引入双链表？  单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。  双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。  双链表中结点类型的描述： t
双向链表--尾插法
ulm23的博客
07-28 1176
双向链表--尾插法
双链表的初始化（头插和尾插）,插入，删除操作
Boyt1317的博客
10-16 1972
双链表的创建（全），插入和删除操作
数据结构中的双向链表的初始化定义
weixin_67728137的博客
09-21 71
双向链表。
建立双链表（尾插法）
muyu_muyu的博客
12-08 3682
双链表存储结构： 要建立双链表，首先要明白双链表的存储结构定义： typedef struct DLinkList{ //存储结构定义 int data; DLinkList * prior; DLinkList * next; } 思想： 该方法是将新节点插入双链表的表尾，为此增加一个尾指针r.使其始终指向当前链表的尾结点 思路： 1.建立头结点L,定义一个尾指针r, 并同时将r指向L。 2.通过for循环将数组元素一个个插入到链表表尾。 指
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
09-04
下面将详细讲解如何在C++中操作双向链表，包括创建、查找、插入和删除节点。 首先，我们需要定义双向链表的节点结构。每个节点包含三个部分：数据（data）、指向前一个节点的指针（prev）和指向后一个节点的指针...
sss.rar_sss_双向链表_链表_链表 插入
09-14
1.双向链表的初始化 2.双向链表的尾插法建立 3.双向链表插入结点 4.双向链表删除结点 5.双向链表遍历链表 6.双向链表按不同的属性查找节点 7.双指针查找节点
JavaScript 双向链表操作实例分析【创建、增加、查找、删除等】
10-15
下面我们将深入分析JavaScript中双向链表的基本操作，包括创建、增加、查找、插入和删除节点。 1. **创建双向链表** 双向链表通常由一个头节点（head）开始，头节点的`prev`属性指向null，表示链表的起点。可以...
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
双向循环链表的头插法和尾插法
weixin_50722786的博客
12-04 1560
我们平常学链表的时候会学单向不循环链表，单向循环链表，双向不循环链表，双向循环链表及内核链表，各种格式的链表。今天我因为忘记双向循环链表的头插法和尾插法的顺序了，特意写一篇文章来巩固一下。首先我根据顺序画一张图（尾插法） 尾插法示意图 头插法如下
双链表详解(初始化、插入、删除、遍历)(数据结构与算法)
最新发布
AII_IIA的博客
11-04 2292
同时，删除节点后必须确保释放相应的内存空间，以防止内存泄漏问题的发生。11. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。7. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。在双链表中删除节点的操作相对比较复杂，因为我们需要维护前驱节点和后继节点之间的指针连接。在双链表中插入节点需要更新前驱节点和后继节点的指针连接，操作相对比较复杂。将 p 结点的next指针，指向q结点的后继结点。程序设计如下：注意修改指针时要注意顺序！
c语言双向链表尾插法,双向链表（前插操作，删除操作）
weixin_30663789的博客
05-22 2729
循环单链表的出现，虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，我们可称之为双(向)链表(DoubleLinked List)。双链表的结构定义如下：typedef structDNode{ElemType data;...
双链表的初始化
m0_65060417的博客
11-05 360
单链表的初始化（带头节点）
双链表的初始化、插入结点、删除结点
m0_56620906的博客
05-02 2309
双链表学习
双向链表的尾插法建表、插入、删除
m0_53002692的博客
08-17 383
双向链表的尾插法建表、插入、删除
编写程序，实现单链表的基本操作：初始化、建表（头插法或尾插法）、查找、插入、删除、求表长。C语言
09-26
可以通过以下代码实现单链表的基本操作： ```c #include #include // 定义链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; // 初始化链表 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值