【链表】双向链表：双向循环链表

最新推荐文章于 2023-05-13 12:11:24 发布
最新推荐文章于 2023-05-13 12:11:24 发布
阅读量282 收藏 1
点赞数
分类专栏： C/C++ 数据结构&算法 文章标签： 链表 数据结构 循环链表 双向链表 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/newcong0123/article/details/105856420
版权

写在前面的话：

  1. 版权声明：本文为博主原创文章，转载请注明出处！
  2. 博主是一个小菜鸟，并且非常玻璃心！如果文中有什么问题，请友好地指出来，博主查证后会进行更正，啾咪~~
  3. 每篇文章都是博主现阶段的理解，如果理解的更深入的话，博主会不定时更新文章。
  4. 本文最后更新时间：2020.4.30

正文开始

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

为了克服单向性这一缺点，便有人设计出了双向链表。双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。所以在双向链表中的结点都有两个指针域，一个指向直接后继，另一个指向直接前驱。

双向循环链表中的指针都是成对出现的：你的next指向我，我的prior指向你。

1. 定义数据结构

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};

2. 设头结点

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

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Dlink;

/* ===============
 功能：设头结点
 返回：void
=============== */
void init_d_link(Dlink *head)
{
    *head = (Dlink)malloc(sizeof(Node));  //为头结点分配空间

    (*head)->prior = *head;
    (*head)->next = *head;
}

int main()
{
    Dlink head;
    init_d_link(&head);

    return 0;
}

3. 插入

3.1 头插

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

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Dlink;

/* ===============
 功能：设头结点
 返回：void
=============== */
void init_d_link(Dlink *head)
{
    *head = (Dlink)malloc(sizeof(Node));  //为头结点分配空间

    (*head)->prior = *head;
    (*head)->next = *head;
}

/* =====================
 功能：从头部插入结点
 返回：void
===================== */
void insert_head_node(Dlink newnode,Dlink head)
{
    newnode->next = head->next;
    head->next->prior = newnode;

    head->next = newnode;
    newnode->prior = head;
}

/* ================
 功能：打印链表
 返回：void
================ */
void display_link(Dlink head)
{
    Dlink temp = head->next;
    while (temp != head)     //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Dlink head;
    Dlink newnode;

    init_d_link(&head);

    for (int i = 0; i < 10; i++)
    {
        newnode = (Dlink)malloc(sizeof(Node));  //为结点分配空间
        newnode->num = i + 1;                   //为结点数据域赋值
        insert_head_node(newnode, head);        //头插
    }

    printf("头插后的链表为 : \n");
    display_link(head);                         //打印链表

    return 0;
}

运行结果：

头插后的链表为 : 
10
9
8
7
6
5
4
3
2
1

3.2 尾插

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

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Dlink;

/* ===============
 功能：设头结点
 返回：void
=============== */
void init_d_link(Dlink *head)
{
    *head = (Dlink)malloc(sizeof(Node));  //为头结点分配空间

    (*head)->prior = *head;
    (*head)->next = *head;
}

/* =====================
 功能：从尾部插入结点
 返回：void
===================== */
void insert_tail_node(Dlink newnode, Dlink head)
{
    head->prior->next = newnode;
    newnode->prior = head->prior;

    newnode->next = head;
    head->prior = newnode;
}

/* ================
 功能：打印链表
 返回：void
================ */
void display_link(Dlink head)
{
    Dlink temp = head->next;
    while (temp != head)     //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Dlink head;
    Dlink newnode;

    init_d_link(&head);

    for (int i = 0; i < 10; i++)
    {
        newnode = (Dlink)malloc(sizeof(Node));  //为结点分配空间
        newnode->num = i + 1;                   //为结点数据域赋值
        insert_tail_node(newnode, head);        //尾插
    }

    printf("尾插后的链表为 : \n");
    display_link(head);                         //打印链表

    return 0;
}

运行结果：

尾插后的链表为 : 
1
2
3
4
5
6
7
8
9
10

3.3 从中间插入

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

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Dlink;

/* ===============
 功能：设头结点
 返回：void
=============== */
void init_d_link(Dlink *head)
{
    *head = (Dlink)malloc(sizeof(Node));  //为头结点分配空间

    (*head)->prior = *head;
    (*head)->next = *head;
}

/* =====================
 功能：从尾部插入结点
 返回：void
===================== */
void insert_tail_node(Dlink newnode, Dlink head)
{
    head->prior->next = newnode;
    newnode->prior = head->prior;

    newnode->next = head;
    head->prior = newnode;
}

/* =====================
 功能：从中间插入结点
 返回：是否成功
===================== */
int insert_mid_node(Dlink newnode, Dlink head,int num)
{
    Dlink temp = head->next;
    while (temp != head)        //遍历链表
    {
        if (temp->num == num)   //判断是否是要找的结点
        {
            newnode->next = temp->next;
            temp->next->prior = newnode;

            temp->next = newnode;
            newnode->prior = temp;

            return 0;
        }
        temp = temp->next;
    }

    return -1;
}

/* ================
 功能：打印链表
 返回：void
================ */
void display_link(Dlink head)
{
    Dlink temp = head->next;
    while (temp != head)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Dlink head;
    Dlink newnode;

    init_d_link(&head);

    for(int i = 0; i < 10; i++)
    {
        newnode = (Dlink)malloc(sizeof(Node));  //为结点分配空间
        newnode->num = i + 1;                   //为结点数据域赋值
        insert_tail_node(newnode, head);        //尾插
    }

    newnode = (Dlink)malloc(sizeof(Node));      //为新结点分配空间
    newnode->num = 11;                          //数据域赋值
    insert_mid_node(newnode, head, 5);          //在数据域为5的结点后插入新结点

    printf("从中间插入后的链表为 : \n");
    display_link(head);                         //打印链表

    return 0;
}

运行结果：

从中间插入后的链表为 : 
1
2
3
4
5
11
6
7
8
9
10

4. 删除结点

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

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *prior;    //prior存放上一个结点的地址
    struct node *next;     //next存放下一个结点的地址
};
 
typedef struct node Node;
typedef Node * Dlink;
 
/* ===============
 功能：设头结点
 返回：void
=============== */
void init_d_link(Dlink *head)
{
    *head = (Dlink)malloc(sizeof(Node));  //为头结点分配空间

    (*head)->prior = *head;
    (*head)->next = *head;
}
 
/* =====================
 功能：从尾部插入结点
 返回：void
===================== */
void insert_tail_node(Dlink newnode, Dlink head)
{
    head->prior->next = newnode;
    newnode->prior = head->prior;
 
    newnode->next = head;
    head->prior = newnode;
}
 
/* ===============
 功能：删除结点
 返回：是否成功
=============== */
int delete_node(int num, Dlink head)
{
    Dlink temp = head->next;
    while (temp != head)         //遍历链表
    {
        if (temp->num == num)    //判断是否是要删除的结点
        {
            temp->prior->next = temp->next;
            temp->next->prior = temp->prior;
 
            free(temp);         //释放
            temp = NULL;        //置空
 
            return 0;
        }
        temp = temp->next;
    }
 
    return -1;
}
 
/* ================
 功能：打印链表
 返回：void
================ */
void display_link(Dlink head)
{
    Dlink temp = head->next;
    while (temp != head)     //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}
 
int main()
{
    Dlink head;
    Dlink newnode;
 
    init_d_link(&head);

    for(int i = 0; i < 10; i++)
    {
        newnode = (Dlink)malloc(sizeof(Node));  //为结点分配空间
        newnode->num = i + 1;                   //为结点数据域赋值
        insert_tail_node(newnode, head);        //尾插
    }
    
    delete_node(7, head);                       //删除数据域为7的结点
    
    printf("删除数据域为7的结点后的链表为 : \n");
    display_link(head);                         //打印链表
 
    return 0;
}

运行结果：

删除数据域为7的结点后的链表为 : 
1
2
3
4
5
6
8
9
10

相关文章

【链表】单链表：不带表头结点
【链表】单链表：带表头结点
【链表】单链表：单循环链表

ReturnZC
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 3721
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
双向循环链表
weixin_53946312的博客
04-17 3245
双向循环链表 一、什么是双向链表？双向循环链表？ 1.双向链表指的是构成链表的每个结点中设立两个指针域：一个指向其直接前驱的指针域prev，一个指向其直接后继的指针域next。这样形成的链表中有两个方向不同的链，故称为双向链表。 2.双向循环链表将双向链表的头结点和尾结点链接起来也能构成循环链表，其称为双向循环链表。 二、双向循环链表的实现 1、结构 typedef int LTDataType; typedef struct ListNode { struct ListNode* next; stru
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1184
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
数据结构初级:链表-双向带头循环链表(C语言)
m0_70088853的博客
05-13 563
链表-双向带头循环链表(C语言)
循环链表和双向链表.ppt
09-20
带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家...
双向循环链表使用实例.doc
最新发布
09-21
接下来，我们定义几个核心函数来操作这个链表： 1. `Creat(DLnode root)`：这是一个创建双向循环链表的函数。它首先为头节点分配内存，然后设置头节点的`next`和`back`指针都指向自身。如果内存分配失败，函数返回0...
Python双向循环链表实现方法分析
09-20
【Python双向循环链表实现方法分析】 Python中的双向循环链表是一种特殊的数据结构，它具有两个指针，分别指向当前节点的前一个节点（prev）和后一个节点（next），并且链表的最后一个节点的next指针指向第一个节点...
如何用C++实现双向循环链表
12-31
双向循环链表：相对于单向循环链表，双向循环链表可从头部反向迭代，这在链表长度很大且需要获取、插入或删除靠近链表尾部元素的时候十分高效。单向循环列表只能从表头正向迭代，执行的时间大于从反向迭代。node.h ...
带头结点的双向循环链表
07-17
双向循环链表是一种高级的数据结构，常用于需要前后移动指针的场景，如实现LRU缓存淘汰策略、编辑器的撤销重做功能等。本项目以C++语言实现了带头结点的双向循环链表，这将有助于我们深入理解这一概念。 首先，双向...
双向循环链表(线性表 栈 队列)
weixin_55742319的博客
01-16 1128
双向循环链表
【数据结构与算法】什么是双向循环链表？以及实现过程
DreamSun的博客
03-24 765
线性表是我们最常用的一种数据结构，线性表包含顺序表和链表，顺序表典型应用就是我们常用的ArrayList，链表的典型应用其中就有我们常用的LinkedList。LinkedList他的底层就是使用链表来存储数据元素的。这篇文章用以总结链表中的双向循环链表，为单链表的结点增加一个指向前驱的指针域，单链表就变成了双链表，将双链表的头尾相连，双链表就成了双向循环链表。链表的缺点线性表的两种实现顺序表、链表。
线性表文档之循环双链表
二木成林
04-05 1434
线性表文档之循环双链表
【C语言】双向循环链表
m0_47329175的博客
06-15 1341
引言 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向链表 双向链表节点 typedef int CycleList_Data; typedef struct Cycle_Node { CycleList_Data data; struct Cycle_Node* front; struct Cycle_Node* next; }Cycl
双向循环链表(图文讲解)
deroy
02-25 2331
文章目录双向循环链表结构体初始化函数添加数据头插删除数据显示函数示例程序一(简易版本)：运行结果：示例程序二 双向循环链表 结构体 typedef struct node { int data; struct node* pre; //指向前驱 struct node* next; //指向后继 }NODE; 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 初始化函数 NODE * Init() { NODE* head = (NODE*)mall
【数据结构】循环链表和双向链表
Jacky_Feng的博客
09-14 1888
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 对于单链表，由于每个结点只存储了向后的指针，到了为标志就停止了向后链的操作。这样，当我们需要找到某个结点的前驱就没办法了。如何从链表中的任一结点出发，访问到链表的全部结点？循环链表就是解决这个麻烦的重要方法。 一、循环链表的定义 1、定义 将单链表中终端结点的指针端由空指针改为指向头指针，就使整个单链表形..
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1266
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
数据结构：循环双向链表
成龙大侠的博客
03-13 150
#include <stdio.h> #include <stdlib.h> #include <string.h> #define ElemType int typedef struct LNode{ ElemType data; struct LNode *prior; struct LNode *next; }LNode, *LinkList;...
数据结构与算法之双向链表
weixin_45669649的博客
04-07 221
数据结构与算法之双向链表 文章目录数据结构与算法之双向链表双向链表标题双向链表节点结构c++代码实现一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 双向链表 双向链表：每一个节点包含两个指针域，一个指针域(pre)指向前一个节点，一个指针域(next)指向后一个节点，另外包含一个数据域用于保存数据。因此双向链表可以向前查询，也可以向后查询。 双向链表单个节点示意图如下： 双向链表如下(改图出处：代码随想录)： 标题双向链表节点结构c++代码实现 struct 提示：这里可以

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值