数据结构----双向链表

已于 2024-08-21 16:25:58 修改
阅读量275 收藏 1
点赞数 4
文章标签： 数据结构 链表
于 2024-08-21 15:43:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64136247/article/details/141394105
版权

一丶双向链表

1.特点

        逻辑结构：线性结构

        存储结构：链式存储
        操作：增删改查

2.函数的操作

创空

双链表从中间插入

双向链表尾插

删除中间节点

删除尾节点

#include <stdio.h>
#include <stdlib.h>
typedef int datatype; // 重定义数据类型
typedef struct linklist
{
    datatype data;           // 数据域
    struct linklist *next;   // 指针域，指向下一个地址
    struct linklist *perior; // 指针域，指向前一个地址
} node_t, *node_p;
typedef struct
{
    node_p head; // 指向头结点
    node_p tail; // 指向尾节点
    int len;     // 记录链的长度
} node;
node *CreateEmpty() // 创建一个空的双向链表
{
    node *p = (node *)malloc(sizeof(node)); // 开辟一个存放头尾指针的空间
    if (NULL == p)
    {
        printf("Cteate err");
        return 0;
    }
    p->len = 0;                                         // 初始化链表长度
    p->head = p->tail = (node_p)malloc(sizeof(node_t)); // 开辟一个链表头结点
    if (NULL == p->head)
    {
        printf("p->head err");
        return NULL;
    }
    p->head->next = p->head->perior = NULL; // 初始化
    return p;
}
int Insert(node *p, int post, int data) // 插入数据，post为要插入的位置，data为要插入的数据
{
    node_p temp = NULL;            // 定义一个指针，用来存放头/尾指针
    if (post < 0 || post > p->len) // 判断插入位置是否超出范围
    {
        printf("Post err");
        return -1;
    }
    node_p p_new = (node_p)malloc(sizeof(node_t)); // 对插入的数据开辟空间
    if (NULL == p_new)                             // 判断是否开辟成功
    {
        printf("P_new err");
        return -1;
    }
    p_new->data = data; // 初始化新节点
    p_new->next = NULL;
    p_new->perior = NULL;
    if (post == p->len) // 如果插入位置在最后，使用尾插法
    {
        p->tail->next = p_new;
        p_new->perior = p->tail;
        p->tail = p_new;
    }
    else
    {
        if (post < p->len / 2) // 当插入位置在前半段时，从头开始向后遍历
        {
            temp = p->head;
            for (int i = 0; i <= post; i++)
                temp = temp->next;
        }
        else // 当插入位置在后半段时，从尾向前遍历
        {
            temp = p->tail;
            for (int i = p->len - 1; i > post; i--)
                temp = temp->perior;
        }
        temp->perior->next = p_new; // 将新节点连接到链表中
        p_new->perior = temp->perior;
        temp->perior = p_new;
        p_new->next = temp;
    }
    p->len++;
    return 0;
}
int IsEmpty(node *p) // 判空
{
    return p->len == 0;
}
int show(node *p) // 输出数据
{
    if (IsEmpty(p)) // 判空
    {
        printf("show err");
        return -1;
    }
    // 顺序遍历，从头节点向后遍历
    printf("正序遍历\n");
    node_p temp = p->head->next;
    while (temp)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
    // 逆序遍历，从尾节点向前遍历
    printf("逆序遍历\n");
    temp = p->tail;
    while (temp != p->head)
    {
        printf("%d ", temp->data);
        temp = temp->perior;
    }
    printf("\n");
}
int Delete(node *p, int post) // 根据位置删除数据。post为要删除的位置
{
    node_p temp = NULL;
    if (IsEmpty(p) || post < 0 || post >= p->len) // 判断删除数据位置是否合理
    {
        printf("del err");
        return -1;
    }
    if (post == p->len - 1) // 如果要删除尾节点，使用以下方法
    {
        node_p p_del = p->tail;
        p->tail = p->tail->perior;
        p->tail->next = NULL;
        free(p_del);
        p_del = NULL;
    }
    else // 删除中间节点
    {
        if (post < p->len / 2) // 当删除位置在前半段时，从头开始向后遍历
        {
            temp = p->head->next;
            for (int i = 0; i < post; i++)
                temp = temp->next;
        }
        else // 当删除位置在后半段时，从后向前遍历
        {
            temp = p->tail;
            for (int i = p->len - 1; i > post; i--)
                temp = temp->perior;
        }
        temp->perior->next = temp->next; // 删除后将删除节点的前后节点相连
        temp->next->perior = temp->perior;
        free(temp); // 将被删除节点释放
        temp = NULL;
    }
    p->len--;
    return 0;
}
int DeleteData(node *p, int data)//删除所有出现的该数据的节点，data为要删除节点的数据
{
    if (IsEmpty(p))//判空
    {
        printf("del data err");
        return -1;
    }
    node_p temp = NULL;
    temp = p->head->next;//跳过头节点
    node_p p_del = NULL;
    while (temp)//循环遍历链表
    {
        if (temp->data == data)//数据域等于data时进入判断
        {
            if (temp == p->tail)//如果为尾节点时
            {
                p_del = temp;
                temp = temp->perior;
                free(p_del);
                p_del = NULL;
            }
            else//如果是中间节点
            {
                p_del = temp;
                p_del->perior->next = p_del->next;
                p_del->next->perior = p_del->perior;
                temp = temp->next;
                free(p_del);
                p_del = NULL;
            }
        }
        else
            temp = temp->next;//更新temp
    }
    return 0;
}
int Modify(node *p, int post, int data) // 修改数据，post为修改位置，data为要修改的数据
{
    if (IsEmpty(p) || post < 0 || post >= p->len) // 判断修改位置是否合理
    {
        printf("Modify err");
        return -1;
    }
    node_p temp = NULL;
    if (post < p->len / 2) // 当修改位置在前半段时，从头开始向后遍历
    {
        temp = p->head->next;
        for (int i = 0; i < post; i++)
            temp = temp->next;
    }
    else // 当修改位置在后半段时，从后向前遍历
    {
        temp = p->tail;
        for (int i = p->len - 1; i > post; i--)
            temp = temp->perior;
    }
    temp->data = data; // 修改数据
    return 0;
}
int Search(node *p, int data) // 根据数据查找数据第一次出现的下标
{
    node_p temp = p->head->next;
    int post = 0;//记录下标
    while (temp)//循环遍历链表
    {
        if (temp->data == data)//返回第一次出现data的下标
            return post;
        temp = temp->next;
        post++;
    }
    return -1;
}
int main(int argc, char const *argv[])
{
    node *p = CreateEmpty();
    Insert(p, 0, 1);
    Insert(p, 1, 2);
    Insert(p, 2, 3);
    Insert(p, 3, 4);
    Insert(p, 4, 5);
    Insert(p, 5, 6);
    printf("最初的链表\n");
    show(p);
    printf("删除指定位置后的链表\n");
    Delete(p, 1);
    show(p);
    printf("修改指定位置后的链表\n");
    Modify(p, 1, 4);
    show(p);
    printf("删除指定数据后的链表\n");
    DeleteData(p, 4);
    show(p);
    return 0;
}

二丶双向循环链表

约瑟夫问题：

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

typedef int datatype;
typedef struct node_t
{
    datatype data;
    struct node_t *prior;
    struct node_t *next;
} link_node_t, *link_list_t;

typedef struct doublelinklist
{
    link_list_t head;
    link_list_t tail;
} double_node_t, *double_list_t;

int main(int argc, const char *argv[])
{
    int i;
    int all_num = 8;   // 猴子总数
    int start_num = 3; // 从3号猴子开始数
    int kill_num = 3;  // 数到几杀死猴子
    link_list_t h = NULL;
    link_list_t pdel = NULL; // 用来指向被杀死猴子的节点
    printf("请您输入猴子的总数，开始号码，出局号码:\n");
    scanf("%d%d%d", &all_num, &start_num, &kill_num);
    // 1.创建一个双向的循环链表
    double_list_t p = (double_list_t)malloc(sizeof(double_node_t)); // 申请头指针和尾指针
    if (NULL == p)
    {
        perror("malloc failed");
        return -1;
    }
    p->head = p->tail = (link_list_t)malloc(sizeof(link_node_t));
    if (NULL == p->tail)
    {
        perror("p->tail malloc failed");
        return -1;
    }
    p->head->data = 1;
    p->head->prior = NULL;
    p->head->next = NULL;
    // 将创建n个新的节点，链接到链表的尾
    for (i = 2; i <= all_num; i++)
    {
        link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
        if (NULL == pnew)
        {
            perror("pnew malloc failed");
            return -1;
        }
        pnew->data = i;
        pnew->prior = NULL;
        pnew->next = NULL;
        //(1)将新的节点链接到链表的尾
        p->tail->next = pnew;
        pnew->prior = p->tail;
        //(2)尾指针向后移动，指向当前链表的尾
        p->tail = pnew;
    }
    //(3)形成双向循环链表
    p->tail->next = p->head;
    p->head->prior = p->tail;
    // 调试程序
#if 0
	while(1)
	{
		printf("%d\n",p->head->data);
		p->head = p->head->next;
		sleep(1);
	}
#endif
    // 2.循环进行杀死猴子
    h = p->head;
    //(1)先将h移动到start_num处，也就是开始数数的猴子号码处
    for (i = 0; i < start_num - 1; i++)
        h = h->next;
    while (h->next != h) // 当h->next == h 就剩一个节点了，循环结束
    {
        //(2)将h移动到即将杀死猴子号码的位置
        for (i = 0; i < kill_num - 1; i++)
            h = h->next;
        //(3)进行杀死猴子，经过上面的循环后，此时的h指向即将杀死的猴子
        h->prior->next = h->next;
        h->next->prior = h->prior;
        pdel = h; // pdel指向被杀死猴子的位置
        printf("kill is -------%d\n", pdel->data);
        h = h->next; // 需要移动，从杀死猴子后的下一个位置开始数
        free(pdel);
    }
    printf("猴王是%d\n", h->data);
    return 0;
}

单向链表与双向（循环）链表的区别：

      在存储空间方面：单链表需要的存储空间比双向链表的要少，因为双向链表不仅保存有指向下一个节点的指针，还保存有指向上一个节点的指针，需要较大的空间来存储双向链表的指针域。

      在处理时间方面：双向链表的插入与删除操作比单链表的效率高，因为如果在后半段删除或者插入可以从后往前遍历到插入或删除位置然后进行操作。

新手嵌入式学习
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3645
双向链表
数据结构-双向链表
qq_43714814的博客
12-12 1955
数据结构-双向链表
数据结构--双向链表
m0_62706197的博客
06-24 942
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
数据结构 -- 链表详解
hu_143的博客
04-27 2368
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
C语言数据结构----双向链表
weixin_55530858的博客
07-21 322
数据结构 双向链表 C语言
Java数据结构--双向链表
m0_74808313的博客
04-23 1717
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
数据结构-双向链表操作
有朋自远方来，不亦乐乎。
08-05 1255
先创建好一个双向链表：代码： 结果： （1）加表头假设新元素节点为 temp，表头节点为 head，则需要做以下 2 步操作即可： （2）加表中 （3）加表尾 2、双向链表删除节点 只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可 3、双向链表查找节点 双向链表同单链表一样，都仅有一个头指针。因此，双链表查找指定元素的实现同单链表类似，都是从表头依次遍历表中元素。 4、双向链表修改节点 通过遍历找到存储有该数据元素的结点，直接更改其数据域即可。 完整代码：
数据结构--双向链表（图文）
SouTY_C的博客
06-26 1073
双向链表相较于单链表的优势在于可以快速访问和操作节点的相邻元素，尤其在需要频繁插入或删除元素的场景中，它提供了更高效的数据操作方式。双向链表常用于实现高级数据结构，如栈、队列、列表等，并且在某些编程语言的标准库中，如C++的STL和Java的LinkedList，都提供了双向链表的实现。双向链表在每个节点处都维护了两个指针，一个指向前一个节点（称为前驱节点），另一个指向下一个节点（称为后继节点）。：头节点的后继指针指向尾节点，尾节点的前驱指针又指回头节点，这样的双向链表形成一个环。情况一：链表只有头节点。
C语言数据结构-双向链表
m0_73678713的博客
12-10 1388
/整型数据//前驱指针//后驱指针}ListNode;
数据结构 -- 双向链表
酷酷学!!!的博客
04-29 1417
双向链表是一种常见的数据结构，它与单向链表相比，在存储元素的同时还记录了元素的前驱节点。双向链表可以实现双向遍历，不仅可以从头到尾遍历元素，还可以从尾到头遍历。这种特性使得双向链表在某些场景下更加方便和高效。在双向链表中，每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。这样，我们可以通过前驱指针和后继指针，方便地进行插入、删除、查找等操作。在接下来的文章中，我们将详细讨论双向链表的实现和常见操作。我们将逐步介绍双向链表的构造、插入、删除、查找等操作，并给出相应的代码示例。
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
链表-使用PHP实现的双向链表数据结构.zip
03-13
在本案例中，"链表-使用PHP实现的双向链表数据结构.zip" 是一个压缩文件，其中包含了一个使用PHP语言实现的双向链表数据结构的示例。双向链表是链表的一种变体，与单向链表不同，它允许从两个方向遍历链表。每个节点...
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 894
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
DKPT的博客
08-16 541
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 542
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
【数据结构入门】二叉树之堆的实现
最新发布
KevinRay_0854的博客
08-20 1104
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
C语言基础（六）
wehpd的博客
08-20 251
一维数组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值