数据结构（学习）2024.8.9（双向链表）

已于 2024-08-09 19:45:29 修改
阅读量653 收藏 7
点赞数 11
分类专栏： 数据结构（学习） 文章标签： 数据结构 学习 链表 c语言 linux 开发语言
于 2024-08-09 19:02:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60450758/article/details/141069099
版权

今天学习的是线性表里面的最后一部分双向链表

栈和队列的相关知识可以查看http://t.csdnimg.cn/R1ls3

链表的相关知识可以查看http://t.csdnimg.cn/NX464

顺序表的相关知识可以查看http://t.csdnimg.cn/5IMAZ

目录

双向链表

结构体

操作函数

1.创建一个空的双向链表

2.向双向链表的指定位置插入数据

3.遍历双向链表

4.删除双向链表指定位置的数据

5.删除双向链表中的指定数据

双向链表的相关操作案例

双向链表

1.逻辑结构：线性结构
2.存储结构：链式存储
3.操作：增、删、改、查

结构体

typedef struct node_t
{
    datatype data;          // 数据域
    struct node_t *next;  // 指向下一个节点的指针 next 下一个
    struct node_t *prior; // 指向前一个节点的指针 prior 前一个
} link_node_t, *link_list_t;

// 将双向链表的头指针和尾指针封装到一个结构体里，有点像学的链式队列

typedef struct doublelinklist
{
    link_list_t head; // 指向双向链表的头指针
    link_list_t tail; // 指向双向链表的尾指针
    int len;
} double_node_t, *double_list_t;

操作函数

1.创建一个空的双向链表

double_list_t createEmptyDoubleLinkList()
{
    double_list_t p = (double_list_t)malloc(sizeof(double_node_t));
    if (p == NULL)
    {
        perror("createEmptyDoubleLinkList函数创建结构体出错\n");
        return NULL;
    }
    p->len = 0;
    p->head = p->tail = (link_list_t)malloc(sizeof(link_node_t));
    if (p->head == NULL)
    {
        perror("createEmptyDoubleLinkList创建链表节点出错\n");
        return NULL;
    }
    p->head->next = NULL;
    p->head->prior = NULL;
    return p;
}

2.向双向链表的指定位置插入数据

int insertIntoDoubleLinkList(double_list_t p, int post, datatype data)
{
    // 1.容错判断
    if (post < 0 || post > p->len)
    {
        perror("insertIntoDoubleLinkList函数出错\n");
        return -1;
    }

    // 2.开辟一个新节点空间存放数据
    link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
    if (pnew == NULL)
    {
        perror("insertIntoDoubleLinkList函数创建新节点出错\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    pnew->prior = NULL;

    link_list_t temp = NULL;
    // 3.将结点插入链表
    //  (1).先对插入的位置进行判断
    if (post == p->len) // 尾插
    {
        p->tail->next = pnew;
        pnew->prior = p->tail;
        p->tail = pnew; // 移动尾指针
    }
    else // 中间插
    {
        // (1)将temp移动到被插入的位置
        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 = 0; i < p->len - 1 - post; i++)
            {
                temp = temp->prior;
            }
        }
        // (2)进行插入操作(先连前面，再连后面)
        temp->prior->next = pnew;
        pnew->prior = temp->prior;
        pnew->next = temp;
        temp->prior = pnew;
    }

    // 长度+1
    p->len++;

    return 0;
}

3.遍历双向链表

void showDoubleLinkList(double_list_t p)
{
    link_list_t temp = NULL;
    printf("正向遍历:\n");
    temp = p->head;
    while (temp->next != NULL)
    {
        temp = temp->next;
        printf("%d ", temp->data);
    }
    printf("\n");

    printf("反向遍历:\n");
    temp = p->tail;
    while (temp != p->head)
    {
        printf("%d ", temp->data);
        temp = temp->prior;
    }
    printf("\n");
}

4.删除双向链表指定位置的数据

int deletePostDoubleLinkList(double_list_t p, int post)
{
    // 1.容错判断
    if (post < 0 || post >= p->len || isEmptyDoubleLinkList(p))
    {
        perror("deletePostDoubleLinkList函数出错\n");
        return -1;
    }
    // 2.对删除的位置进行判断
    link_list_t temp = NULL;
    if (post == p->len - 1) // 尾删
    {
        // 向前移动尾指针
        p->tail = p->tail->prior;

        // 释放被删除的节点
        free(p->tail->next);
        p->tail->next = NULL;
    }
    else // 中间删
    {
        // (1)将temp移动到要删除的位置
        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 = 0; i < p->len - 1 - post; i++)
            {
                temp = temp->prior;
            }
        }
        // (2)进行删除
        temp->prior->next = temp->next;
        temp->next->prior = temp->prior;

        free(temp);
        temp = NULL;
    }

    // 长度-1
    p->len--;
    return 0;
}

5.删除双向链表中的指定数据

int deleteDataDoubleLinkList(double_list_t p, datatype data)
{
    if (isEmptyDoubleLinkList(p))
    {
        perror("deleteDataDoubleLinkList函数出错\n");
        return -1;
    }
    link_list_t q = p->head->next;
    while (q != NULL)
    {
        if (q->data == data) // 删除
        {
            if (q == p->tail) // 尾删
            {
                p->tail = p->tail->prior;
                free(p->tail->next);
                p->tail->next = NULL;
                q = NULL;
            }
            else // 中间删
            {
                q->prior->next = q->next;
                q->next->prior = q->prior;
                link_list_t pdel = q;
                q = q->next;
                free(pdel);
                pdel = NULL;
            }
            p->len--;
        }
        else // 不相等
        {
            q = q->next;
        }
    }
    return 0;
}

双向链表的相关操作案例

头文件doublelinklist.h：

#ifndef _DOUBLELINKLIST_H_
#define _DOUBLELINKLIST_H_
#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node_t
{
	datatype data;		  // 数据域
	struct node_t *next;  // 指向下一个节点的指针 next 下一个
	struct node_t *prior; // 指向前一个节点的指针 prior 前一个
} link_node_t, *link_list_t;

// 将双向链表的头指针和尾指针封装到一个结构体里
// 思想上有点像学的链式队列
typedef struct doublelinklist
{
	link_list_t head; // 指向双向链表的头指针
	link_list_t tail; // 指向双向链表的尾指针
	int len;
} double_node_t, *double_list_t;

// 1.创建一个空的双向链表
double_list_t createEmptyDoubleLinkList();
// 2.向双向链表的指定位置插入数据 post位置， data数据
int insertIntoDoubleLinkList(double_list_t p, int post, datatype data);
// 3.遍历双向链表
void showDoubleLinkList(double_list_t p);
// 4.删除双向链表指定位置的数据
int deletePostDoubleLinkList(double_list_t p, int post);
// 5.判断双向链表是否为空
int isEmptyDoubleLinkList(double_list_t p);
// 6.求双向链表的长度
int lengthDoubleLinkList(double_list_t p);
// 7.查找指定数据出现的位置 data被查找的数据
int searchPostDoubleLinkList(double_list_t p, datatype data);
// 8.修改指定位置的数据,post修改的位置 data被修改的数据
int changeDataDoubleLinkList(double_list_t p, int post, datatype data);
// 9.删除双向链表中的指定数据 data代表删除所有出现的data数据
int deleteDataDoubleLinkList(double_list_t p, datatype data);
#endif

双向链表函数doublelinklist.c：

#include "doublelinklist.h"
// 1.创建一个空的双向链表
double_list_t createEmptyDoubleLinkList()
{
    double_list_t p = (double_list_t)malloc(sizeof(double_node_t));
    if (p == NULL)
    {
        perror("createEmptyDoubleLinkList函数创建结构体出错\n");
        return NULL;
    }
    p->len = 0;
    p->head = p->tail = (link_list_t)malloc(sizeof(link_node_t));
    if (p->head == NULL)
    {
        perror("createEmptyDoubleLinkList创建链表节点出错\n");
        return NULL;
    }
    p->head->next = NULL;
    p->head->prior = NULL;
    return p;
}

// 2.向双向链表的指定位置插入数据 post位置， data数据
int insertIntoDoubleLinkList(double_list_t p, int post, datatype data)
{
    // 1.容错判断
    if (post < 0 || post > p->len)
    {
        perror("insertIntoDoubleLinkList函数出错\n");
        return -1;
    }

    // 2.开辟一个新节点空间存放数据
    link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
    if (pnew == NULL)
    {
        perror("insertIntoDoubleLinkList函数创建新节点出错\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    pnew->prior = NULL;

    link_list_t temp = NULL;
    // 3.将结点插入链表
    //  (1).先对插入的位置进行判断
    if (post == p->len) // 尾插
    {
        p->tail->next = pnew;
        pnew->prior = p->tail;
        p->tail = pnew; // 移动尾指针
    }
    else // 中间插
    {
        // (1)将temp移动到被插入的位置
        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 = 0; i < p->len - 1 - post; i++)
            {
                temp = temp->prior;
            }
        }
        // (2)进行插入操作(先连前面，再连后面)
        temp->prior->next = pnew;
        pnew->prior = temp->prior;
        pnew->next = temp;
        temp->prior = pnew;
    }

    // 长度+1
    p->len++;

    return 0;
}

// 3.遍历双向链表
void showDoubleLinkList(double_list_t p)
{
    link_list_t temp = NULL;
    printf("正向遍历:\n");
    temp = p->head;
    while (temp->next != NULL)
    {
        temp = temp->next;
        printf("%d ", temp->data);
    }
    printf("\n");

    printf("反向遍历:\n");
    temp = p->tail;
    while (temp != p->head)
    {
        printf("%d ", temp->data);
        temp = temp->prior;
    }
    printf("\n");
}

// 4.删除双向链表指定位置的数据
int deletePostDoubleLinkList(double_list_t p, int post)
{
    // 1.容错判断
    if (post < 0 || post >= p->len || isEmptyDoubleLinkList(p))
    {
        perror("deletePostDoubleLinkList函数出错\n");
        return -1;
    }
    // 2.对删除的位置进行判断
    link_list_t temp = NULL;
    if (post == p->len - 1) // 尾删
    {
        // 向前移动尾指针
        p->tail = p->tail->prior;

        // 释放被删除的节点
        free(p->tail->next);
        p->tail->next = NULL;
    }
    else // 中间删
    {
        // (1)将temp移动到要删除的位置
        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 = 0; i < p->len - 1 - post; i++)
            {
                temp = temp->prior;
            }
        }
        // (2)进行插入删除
        temp->prior->next = temp->next;
        temp->next->prior = temp->prior;

        free(temp);
        temp = NULL;
    }

    // 长度-1
    p->len--;
    return 0;
}
// 5.判断双向链表是否为空
int isEmptyDoubleLinkList(double_list_t p)
{
    return p->len == 0;
}
// 6.求双向链表的长度
int lengthDoubleLinkList(double_list_t p)
{
    return p->len;
}

// 7.查找指定数据出现的位置 data被查找的数据
int searchPostDoubleLinkList(double_list_t p, datatype data)
{
    link_list_t q = p->head;
    int post = 0;
    while (q->next != NULL)
    {
        q = q->next;
        if (q->data == data)
        {
            return post;
        }
        post++;
    }
    return -1;
}

// 8.修改指定位置的数据,post修改的位置 data被修改的数据
int changeDataDoubleLinkList(double_list_t p, int post, datatype data)
{
    // 1.容错判断
    if (post < 0 || post >= p->len)
    {
        perror("changeDataDoubleLinkList函数出错\n");
        return -1;
    }

    // 2.移动指针
    link_list_t temp = NULL;
    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 = 0; i < p->len - 1 - post; i++)
        {
            temp = temp->prior;
        }
    }
    // 3.修改数据
    temp->data = data;
    return 0;
}

// 9.删除双向链表中的指定数据 data代表删除所有出现的data数据
int deleteDataDoubleLinkList(double_list_t p, datatype data)
{
    if (isEmptyDoubleLinkList(p))
    {
        perror("deleteDataDoubleLinkList函数出错\n");
        return -1;
    }
    link_list_t q = p->head->next;
    while (q != NULL)
    {
        if (q->data == data) // 删除
        {
            if (q == p->tail) // 尾删
            {
                p->tail = p->tail->prior;
                free(p->tail->next);
                p->tail->next = NULL;
                q = NULL;
            }
            else // 中间删
            {
                q->prior->next = q->next;
                q->next->prior = q->prior;
                link_list_t pdel = q;
                q = q->next;
                free(pdel);
                pdel = NULL;
            }
            p->len--;
        }
        else // 不相等
        {
            q = q->next;
        }
    }
    return 0;
}

主函数main.c：

#include "doublelinklist.h"

int main(int argc, char const *argv[])
{
    int post;
    int data;
    double_list_t p = createEmptyDoubleLinkList();

    insertIntoDoubleLinkList(p, 0, 1);
    insertIntoDoubleLinkList(p, 1, 2);
    insertIntoDoubleLinkList(p, 2, 3);
    insertIntoDoubleLinkList(p, 3, 4);
    printf("双向链表为:\n");
    showDoubleLinkList(p);
    printf("双向链表的长度为：\n");
    printf("%d\n", lengthDoubleLinkList(p));

    printf("请输入你要插入的数据的位置和数据:\n");
    scanf(" %d %d", &post, &data);
    insertIntoDoubleLinkList(p, post, data);
    printf("插入数据以后的双向链表为:\n");
    showDoubleLinkList(p);

    printf("请输入你要删除的数据的位置:\n");
    scanf(" %d", &post);
    deletePostDoubleLinkList(p, post);
    printf("删除以后的双向链表为:\n");
    showDoubleLinkList(p);

    printf("双向链表的长度为：\n");
    printf("%d\n", lengthDoubleLinkList(p));

    printf("请输入你要查询的数据：\n");
    scanf(" %d", &data);
    printf("该数据的位置为：%d\n", searchPostDoubleLinkList(p, data));

    printf("请输入你要修改的数据的位置和数据:\n");
    scanf(" %d %d", &post, &data);
    changeDataDoubleLinkList(p, post, data);
    printf("修改数据以后的双向链表为:\n");
    showDoubleLinkList(p);

    printf("请输入你要删除的数据:\n");
    scanf(" %d", &data);
    deleteDataDoubleLinkList(p, data);
    printf("删除数据以后的双向链表为:\n");
    showDoubleLinkList(p);

    printf("双向链表的长度为：\n");
    printf("%d\n", lengthDoubleLinkList(p));

    return 0;
}

何物爱惜雨#1110
关注
专栏目录
数据结构之双向带头循环链表
好兄弟起把大狙
10-10 135
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
数据结构（学习）2024.8.12（树）
何物爱惜雨的博客
08-12 1036
树的概念、特征，二叉树的概念、分类、性质、存储结构和遍历
数据结构 2024.8.5
2301_80018093的博客
08-05 202
【代码】数据结构 2024.8.5。
数据结构（学习）2024.8.6（顺序表）
何物爱惜雨的博客
08-06 1401
数据结构（数据，逻辑结构，存储结构和操作），算法的相关定义和知识（算法的特性，判断标准），时间复杂度，空间复杂度，顺序表（特点，命名规则，相关操作）
2024.8.3-8.4数据结构作业
qq_63490254的博客
08-03 521
Hello world!
数据结构第三次作业（2024.8.4）（第十二次作业）
qq_71440651的博客
08-05 104
作业，数据结构，链表
学习记录——day15 数据结构 链表
weixin_64918301的博客
07-19 787
1、优点:能够直接通过下标进行定位元素，访问效率高，对元素进行查找和修改比较快2、不足:插入和删除元素需要移动大量的元素，效率较低3、缺点:存储数据元素有上限，当达到MAX后，就不能再添加元素了。
高阶数据数据结构 2024.7.9-24.7.15
he20021221的博客
07-18 1732
高阶数据结构：AVL树、红黑树、并查集、位图、布隆过滤器、LUR CaChe、B-树、图
王道数据结构课件2024
06-16
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中有效地存储和组织数据，以便进行高效的检索、...总之，"王道数据结构课件2024"是一个全面的学习资源，旨在帮助学生深入理解和熟练掌握数据结构这一关键领域。
数据结构篇•卷4•2020天勤计算机考研八套模拟卷.pdf
02-18
### 数据结构知识点解析 #### 一、选择题知识点解析 **1. 非空循环单链表与静态链表** - **非空循环单链表：** - 在题目中提到的“非空循环单链表head的尾结点p满足p→next=head”，这是非空循环单链表的基本...
(2024)跳槽涨薪必备精选面试题.pdf
06-29
- **LinkedList** 基于双向链表实现，插入删除操作效率高，不支持随机访问元素。 3. **CopyOnWriteArrayList的底层原理** - `CopyOnWriteArrayList` 使用写入时复制策略，在写操作时创建新的数组，并进行修改。 ...
【手写数据库内核组件】0104双向循环链表，麻雀虽小也需要精心设计，整体分层抽象，遍历的多种形式
一个追逐梦想的码农
09-06 600
前文介绍了单向链表，它结构简单易用，但是需要对数据经常随机插入和删除的场景，就显得非常麻烦，需要遍历找到前驱节点。 今天来分享一下双向循环链表，每个节点有前继与后继指针，同时它链表的头和尾也是相连的，这样就可以在任意位置开始遍历。 本文就来介绍双向循环链表有那些操作，来设计一个通用的双向循环链表组件。
Java中各种数据结构如何使用stream流
a486368464的博客
09-07 620
Stream允许你以声明方式处理数据集合（包括数组、集合等）
数据结构：线性表的顺序存储
weixin_74300052的博客
09-08 626
Hello,大家好，我是小珑也要变强（也是小珑），我是易编程·终身成长社群的一名“创始团队·嘉宾”和“内容共创官”,现在我来为大家介绍一下有关物联网-嵌入式方面的内容。线性表的顺序存储结构我们也叫做顺序表，它指的是用一段地址连续的存储单元依次存储线性表中的数据元素。如下图：通过上图，结合之前的C语言学习，我们基本明白，线性表的本质就是我们对于数组的操作。
【数据结构初阶】链表分类与双向带头循环链表接口实现
fhvyxyci的博客
09-07 1331
1. 链表的分类 2. 双向带头循环链表接口实现 2. 1 结点声明 2. 2 创建链表节点 2. 3 初始化链表 2. 4 打印链表 2. 5 尾插 2. 6 判空 2. 7 尾删 2. 8 头插 2. 9 头删 2. 10 查找 2. 11 在指定位置删除与插入 2. 12 销毁 3. 链表接口测试 4. 单链表与双链表 5. 顺序表与链表
数据结构-图
最新发布
ya888g
09-13 381
邻接表（Adjacency List）：使用链表或数组列表表示图，其中每个顶点都有一个与之关联的链表或数组列表，存储与其相邻的顶点。广度优先搜索（Breadth-First Search, BFS）：从某个顶点出发，逐层访问其相邻顶点，直到所有可达顶点都被访问过。最小生成树问题：在一个连通图中找到一棵包含所有顶点的树，使得树的所有边的权值之和最小，如Kruskal算法、Prim算法等。权重（Weight）：与边相关联的数值，表示边的某种属性，如距离、成本等。顶点（Vertex）：图中的节点，通常表示为V。
数据结构(并查集) How did you do it? 怎么做到的！！!
zyh_Jan22的博客
09-10 819
并查集的历史1964年， Bernard A. Galler 和 Michael J. Fischer 首次描述了不相交的并查集，1975 年，Robert Tarjan 是第一个证明O(ma(n))（）算法时间复杂度的上限，并且在 1979 年表明这是受限情况的下限。2007 年，Sylvain Conchon 和 Jean-Christophe Filliâtre 开发并查集数据结构的半持久版本，并使用证明助手 Coq 将其正确性形式化。
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
BamBoo_Bean的博客
09-10 641
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值