深度探索 C 语言数据结构——双链表：从键盘输入到增删查改及去重操作全解析

🕗 发布于 2024-11-22 10:41 c语言 数据结构 开发语言 链表算法

C 语言数据结构——双链表：从键盘输入到增删查改及去重操作全解析

例题
一、创建双链表
- （一）定义双链表
- （二）双链表的创建函数
二、双链表的增加操作
三、双链表的删除操作
四、双链表去重操作
五、销毁双链表
六、菜单函数的实现
七、主函数的实现
八、本文的所有源代码

例题

请你基于 C 语言实现一个双链表数据结构，并完成以下功能：

创建链表：

编写函数通过键盘输入一系列整数来创建一个双链表，输入以特定值（例如 -1）作为结束标志。

增加节点操作：

实现一个函数，能够在双链表的指定位置插入新的节点。用户需输入要插入的位置（从 1 开始计数，表示第几个节点之前插入）以及要插入节点的值。

删除节点操作：

编写函数，可根据用户输入的节点值准确删除双链表中对应的节点。若存在多个相同值的节点，需全部删除。

链表销毁：

当完成所有操作后，实现一个函数将双链表彻底销毁，释放其所占用的全部内存资源，确保无内存泄漏。

去重操作：

编写函数对已创建的双链表中的数据进行检查，依据节点的数据域判断是否存在重复的值。若有重复节点，仅保留其中一个，删除其余重复的节点，使得链表中每个数据值仅出现一次。

一、创建双链表

我们先回顾一下什么是双链表
双向链表是一种链式数据结构，每个节点包含两个指针，分别指向前驱和后继节点

在这里插入图片描述

双链表的应用场景

例如，在缓存机制中，可以使用双向链表来实现LRU（最近最少使用）缓存淘汰算法。
在操作系统的任务管理中，也可以使用双向链表来维护任务队列，以便快速地添加、删除和查找任务。
此外，双向链表还常用于实现文本编辑器中的撤销和重做功能、图的深度优先搜索和广度优先搜索等算法中。

（一）定义双链表

接下来定义一个双链表


// 定义双向链表（结点）结构
typedef int LTDatatype;
typedef struct ListNode 
{
    LTDatatype data;
    struct ListNode* next;//下一个节点
    struct ListNode* prev;//上一个节点
} LTNode;

大家思考一下这段话是做什么的？typedef int LTDatatype;

在这个结构体定义中，data 字段的类型被定义为 LTDatatype，即 int，因此，这段话是将所有使用 data的地方都会自动更新为int数据类型，而不需要逐个修改每个字段的定义

（二）双链表的创建函数

// 创建新节点
LTNode* buyNode(LTDatatype x) 
{
    LTNode* node = (LTNode*)malloc(sizeof(LTNode));
    node->data = x;
    node->next = node->prev = node;
    return node;
}

这个函数的主要目的是创建一个新的双向链表节点，并对其进行初始化，然后返回这个新创建的节点指针

node->data = x

将传入的参数 x 的值赋给新节点的 data 成员变量

node->next = node->prev = node

这行代码将新节点的 next（指向下一个节点的指针）和 prev（指向前一个节点的指针）都初始化为指向自身形成单个双链表

在这里插入图片描述

// 初始化双向链表
LTNode* LTInit() 
{
    LTNode* phead = buyNode(-1);
    return phead;
}

该函数用于初始化一个双向链表，具体做法是创建一个带有特殊标记值（这里是 -1 ）的头节点，并返回这个头节点的指针，这个头节点将作为整个双向链表的起始标识

总而言之就是将-1设置为双链表的头结点

二、双链表的增加操作

（一）头插

头插操作图解
在这里插入图片描述


// 头插操作
void LTPushFront(LTNode* phead, LTDatatype x) 
{
    assert(phead);
    LTNode* newnode = buyNode(x);
    newnode->next = phead->next;
    newnode->prev = phead;

    phead->next->prev = newnode;
    phead->next = newnode;
}

设置新节点的指针关系：

newnode->next = phead->next;：将新节点的next指针指向头节点phead的下一个节点（即原来链表中的第一个实际数据节点）。
newnode->prev = phead;：将新节点的prev指针指向头节点phead,调整头节点及其下一个节点的指针关系完成插入：
phead->next->prev = newnode;：将原来头节点下一个节点的prev指针指向新节点newnode。
phead->next = newnode：将头节点的next指针指向新节点newnode，使得新节点成为新的链表首节点（在不考虑特殊头节点存储数据的情况下）

（二）尾插

在这里插入图片描述

// 尾插操作
void LTPushBack(LTNode* phead, LTDatatype x) 
{
    assert(phead);
    LTNode* newnode = buyNode(x);
    newnode->prev = phead->prev;
    newnode->next = phead;

    phead->prev->next = newnode;
    phead->prev = newnode;
}

设置新节点的指针关系：

newnode->prev = phead->prev;：将新节点的prev指针指向当前链表尾节点（因为phead->prev指向链表的尾节点，在带有哑节点的链表结构中通常是这样的设计）。
newnode->next = phead;：将新节点的next指针指向头节点phead。

最后调整链表尾节点和头节点的指针关系以完成插入：

phead->prev->next = newnode;：将原来的尾节点的next指针指向新节点newnode。
phead->prev = newnode;：将头节点的prev指针指向新节点newnode，使得新节点成为新的尾节点

（三）在pos位置之后插入数据

在这里插入图片描述


// 在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDatatype x) 
{
    assert(pos);

    LTNode* newnode = buyNode(x);
    newnode->next = pos->next;
    newnode->prev = pos;

    pos->next->prev = newnode;
    pos->next = newnode;
}

newnode->next = pos->next;：将新节点的next指针指向pos节点的下一个节点。
newnode->prev = pos;：将新节点的prev指针指向pos节点，建立新节点与pos节点的双向连接。
pos->next->prev = newnode;：将pos节点原来的下一个节点的prev指针指向新节点newnode。
pos->next = newnode;：将pos节点的next指针指向新节点newnode，完成插入操作

三、双链表的删除操作

（一）头删

在这里插入图片描述


// 头删操作
void LTPopFront(LTNode* phead) 
{
    assert(!LTEmpty(phead));

    LTNode* del = phead->next;
    del->next->prev = phead;
    phead->next = del->next;

    free(del);
    del = NULL;
}

首先通过LTNode* del = phead->next; 找到要删除的节点，也就是链表的第二个节点，并把这个节点的指针存到 del 变量里
然后进行双向链表的指针调整：
del->next->prev = phead;
这一步是让要删除节点（del）的下一个节点的 prev（前驱）指针指向链表的头节点 phead。这样就把链表中 del 节点后面的部分和头节点重新连接起来了，保证链表在删除 del 节点后还是一个完整的双向链表。
phead->next = del->next;
这一步是让头节点 phead 的 next（后继）指针指向要删除节点（del）的下一个节点。这就相当于把要删除的节点从链表中 “摘” 出去了，链表现在跳过了 del 节点直接连到它后面的节点

（二）尾删


// 尾删操作
void LTPopBack(LTNode* phead) 
{
    assert(!LTEmpty(phead));

    LTNode* del = phead->prev;
    del->prev->next = phead;
    phead->prev = del->prev;

    free(del);
    del = NULL;
}

首先，通过LTNode* del = phead->prev;语句找到要删除的节点。
在双向链表中，表头节点的prev指针指向链表的最后一个节点，所以这里将链表的最后一个节点的指针赋给del变量，从而确定了要删除的目标节点。
接下来进行双向链表的指针调整操作：
del->prev->next = phead;这行代码是让要删除节点（del）的前一个节点（即倒数第二个节点）的next指针指向链表的头节点phead。这样就重新建立了链表倒数第二个节点与头节点的后继关系，使得在删除del节点后，链表的后半部分能够正确地与头节点连接起来，保证了链表结构的完整性。
phead->prev = del->prev;这行代码则是让头节点phead的prev指针指向要删除节点（del）的前一个节点（即倒数第二个节点）。

（三）删除指定位置节点


// 删除指定位置节点
void LTErase(LTNode* pos) 
{

    assert(pos);
    pos->prev->next = pos->next;
    pos->next->prev = pos->prev;

    free(pos);
    pos = NULL;
}

对于双向链表，每个节点都有指向前一个节点的prev指针和指向后一个节点的next指针。
当要删除节点pos时：
pos->prev->next = pos->next;这行代码使得pos节点的前一个节点（通过pos->prev获取）的next指针指向pos节点的后一个节点（通过pos->next获取）。
这样就重新建立了pos节点前后节点之间的后继关系，相当于-在链表中 “跳过” 了要删除的pos节点，使得链表在删除pos节点后这部分的连接依然是正确的。
pos->next->prev = pos->prev;这行代码则是让pos节点的后一个节点（通过pos->next获取）的prev指针指向pos节点的前一个节点（通过pos->next获取）

四、双链表去重操作

// 对双链表去重函数
void ListRemoveDuplicates(LTNode* phead) 
{
    if (phead == NULL) 
    {
        return;
    }

    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        LTNode* pnext = pcur->next;
        LTNode* prev = pcur->prev;
        LTNode* finder = pcur->next;
        while (finder != phead) 
        {
            if (finder->data == pcur->data) 
            {
                prev->next = finder->next;
                finder->next->prev = prev;
                LTNode* temp = finder;
                finder = finder->next;
                free(temp);
            }
            else 
            {
                prev = finder;
                finder = finder->next;
            }
        }
        pcur = pnext;
    }
}

首先检查链表是否为空：

函数一开始先看看传入的链表头指针 phead 是不是为空。要是为空，那就说明链表不存在或者是空链表呀，这种情况下就不用做去重操作了，直接返回就行。

遍历链表：

先让一个指针 pcur 指向链表头节点 phead 的下一个节点，因为通常头节点可能只是个标识，真正要处理数据的节点从它下一个开始。
然后通过一个 while 循环，只要 pcur 指向的节点不是头节点（因为双向链表遍历一圈回来就到头节点了），就一直循环下去。在每次循环结束时，会把 pcur 指针更新为它当前指向节点的下一个节点，这样就能遍历整个链表啦。

查找并删除重复节点：

对于 pcur 指向的每一个当前节点：
先准备好几个指针，一个指向 pcur 的下一个节点 pnext，一个指向 pcur 的前一个节点 prev，还有一个 finder 指针也指向 pcur 的下一个节点。
然后让 finder 指针从 pcur 的下一个节点开始，沿着链表往后找，一直找到头节点为止（这就是一圈啦）。

在找的过程中：

如果发现 finder 指针指向的节点数据值和 pcur 指向的节点数据值一样，那就说明找到了重复节点，这时候就要删掉它啦。
删掉的办法就是调整一下链表的指针，让 pcur 的前一个节点 prev 的下一个指针指向 finder 指针指向节点的下一个节点，同时让 finder 指针指向节点的下一个节点的前一个指针指向 prev。然后把要删掉的节点用一个临时指针 temp 存起来，把 finder 指针更新为它下一个节点，最后用 free 把存起来的节点释放掉，这样就删掉重复节点啦。
如果发现 finder 指针指向的节点数据值和 pcur 指向的节点数据值不一样，那就把 prev 指针更新为 finder 指针指向的节点，把 finder 指针更新为它下一个节点，接着继续找有没有其他重复节点

五、销毁双链表


// 销毁双向链表
void LTDesTroy(LTNode* phead) 
{
    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        LTNode* next = pcur->next;
        free(pcur);
        pcur = next;
    }
    free(phead);
    phead = NULL;
}

六、菜单函数的实现


// 菜单函数
int menu() {
    int choose;
    printf("请选择对双链表的操作：\n");
    printf("1. 删除数据\n");
    printf("2. 插入数据\n");
    printf("3. 销毁双链表\n");
    printf("4. 查找数据\n");
    printf("5. 对双链表去重\n");
    printf("请输入你的选择：");
    scanf("%d", &choose);
    return choose;
}

// 插入数据菜单函数
int insmenu() {
    int choose;
    printf("请选择插入数据的方式：\n");
    printf("1. 头插\n");
    printf("2. 尾插\n");
    printf("3. 指定一个数之前插入\n");
    printf("请输入你的插入操作选择：\n");
    scanf("%d", &choose);
    return choose;
}

// 删除数据菜单函数
int delmenu() {
    int delchoice;
    printf("1. 在头部删除节点\n");
    printf("2. 在尾部删除节点\n");
    printf("3. 删除指定位置的节点\n");
    printf("4. 删除指定值的节点\n");
    printf("请输入你的删除操作选择: \n");
    scanf("%d", &delchoice);
    return delchoice;
}

七、主函数的实现

int main() 
{
    LTNode* plist = LTInit();
    int num;
    printf("请输入双链表的节点个数：");
    scanf("%d", &num);
    printf("请依次输入双链表的节点值：\n");

    for (int i = 0; i < num; i++) 
    {
        int value;
        scanf("%d", &value);
        LTPushBack(plist, value);
    }

    printf("初始化后的双链表为：\n");
    LTPrint(plist);

    int input;
    LTNode* find;
    int value;

    do {
        input = menu();
        switch (input) 
        {
        case 1: 
        {
            int delchoice = delmenu();
            switch (delchoice) 
            {
            case 1:
                if (!LTEmpty(plist)) 
                {
                    LTPopFront(plist);
                }
                break;
            case 2:
                if (!LTEmpty(plist)) 
                {
                    LTPopBack(plist);
                }
                break;
            case 3: {
                printf("请输入要删除节点的位置：");
                int pos;
                scanf("%d", &pos);
                LTNode* pcur = plist->next;
                for (int i = 0; i < pos; i++) 
                {
                    pcur = pcur->next;
                }
                LTErase(pcur);
                break;
            }
            case 4: 
            {
                printf("请输入要删除的值：");
                scanf("%d", &value);
                find = LTFind(plist, value);
                if (find != NULL) 
                {
                    LTErase(find);
                }
                break;
            }
            default:
                printf("无效的删除操作选择\n");
                break;
            }
            break;
        }
        case 2: 
        {
            int inschoice = insmenu();
            switch (inschoice) 
            {
            case 1:

                printf("请输入要插入的值：");
                scanf("%d", &value);
                LTPushFront(plist, value);
                break;
            case 2:

                printf("请输入要插入的值：");
                scanf("%d", &value);
                LTPushBack(plist, value);
                break;
            case 3: 
                {
                printf("请输入指定的数：");
                scanf("%d", &value);
                find = LTFind(plist, value);
                if (find != NULL) 
                {
                    printf("请输入要插入的值：");
                    scanf("%d", &value);
                    LTInsert(find, value);
                }
                else 
                {
                    printf("未找到指定的数\n");
                }
                break;
            }
            default:
                printf("无效的插入操作选择\n");
                break;
            }
            break;
        }
        case 3:
            LTDesTroy(plist);
            plist = NULL;
            break;
        case 4:
            printf("请输入要查找的值：");
            scanf("%d", &value);
            find = LTFind(plist, value);
            if (find != NULL) {
                printf("找到了，该值所在节点的下一个节点数据为：%d\n", find->next->data);
            }
            else 
            {
                printf("未找到指定的值\n");
            }
            break;
        case 5:
            ListRemoveDuplicates(plist);
            break;
        default:
            printf("无效的操作选择\n");
            break;
        }


        if (plist != NULL) 
        {
            LTPrint(plist);
        }
    } while (input != 3);

    return 0;
}

八、本文的所有源代码

List.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

// 定义双向链表（结点）结构
typedef int LTDatatype;
typedef struct ListNode 
{
    LTDatatype data;
    struct ListNode* next;//下一个节点
    struct ListNode* prev;//上一个节点
} LTNode;

// 初始化
LTNode* LTInit();
// 销毁链表
void LTDesTroy(LTNode* phead);
// 打印链表
void LTPrint(LTNode* phead);
// 判断链表是否为空
bool LTEmpty(LTNode* phead);
// 尾插
void LTPushBack(LTNode* phead, LTDatatype x);
// 头插
void LTPushFront(LTNode* phead, LTDatatype x);
// 尾删
void LTPopBack(LTNode* phead);
// 头删
void LTPopFront(LTNode* phead);
// 在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDatatype x);
// 删除指定位置节点
void LTErase(LTNode* pos);
// 查找指定值的节点
LTNode* LTFind(LTNode* phead, LTDatatype x);
// 菜单函数
int menu();
// 插入数据菜单函数
int insmenu();
// 删除数据菜单函数
int delmenu();
// 对双链表去重函数
void ListRemoveDuplicates(LTNode* phead);

List.c文件

#pragma warning(disable:4996)
#include "List.h"
// 创建新节点
LTNode* buyNode(LTDatatype x) 
{
    LTNode* node = (LTNode*)malloc(sizeof(LTNode));
    node->data = x;
    node->next = node->prev = node;
    return node;
}

// 初始化双向链表
LTNode* LTInit() 
{
    LTNode* phead = buyNode(-1);
    return phead;
}

// 销毁双向链表
void LTDesTroy(LTNode* phead) 
{
    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        LTNode* next = pcur->next;
        free(pcur);
        pcur = next;
    }
    free(phead);
    phead = NULL;
}

// 打印双向链表
void LTPrint(LTNode* phead) 
{
    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        printf("%d <-> ", pcur->data);
        pcur = pcur->next;
    }
    printf("\n");
}

// 判断双向链表是否为空
bool LTEmpty(LTNode* phead) 
{
    assert(phead);
    return phead->next == phead;
}

// 尾插操作
void LTPushBack(LTNode* phead, LTDatatype x) 
{
    assert(phead);
    LTNode* newnode = buyNode(x);
    newnode->prev = phead->prev;
    newnode->next = phead;

    phead->prev->next = newnode;
    phead->prev = newnode;
}

// 头插操作
void LTPushFront(LTNode* phead, LTDatatype x) 
{
    assert(phead);
    LTNode* newnode = buyNode(x);
    newnode->next = phead->next;
    newnode->prev = phead;

    phead->next->prev = newnode;
    phead->next = newnode;
}

// 尾删操作
void LTPopBack(LTNode* phead) 
{
    assert(!LTEmpty(phead));

    LTNode* del = phead->prev;
    del->prev->next = phead;
    phead->prev = del->prev;

    free(del);
    del = NULL;
}

// 头删操作
void LTPopFront(LTNode* phead) 
{
    assert(!LTEmpty(phead));

    LTNode* del = phead->next;
    del->next->prev = phead;
    phead->next = del->next;

    free(del);
    del = NULL;
}

// 在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDatatype x) 
{
    assert(pos);

    LTNode* newnode = buyNode(x);
    newnode->next = pos->next;
    newnode->prev = pos;

    pos->next->prev = newnode;
    pos->next = newnode;
}

// 删除指定位置节点
void LTErase(LTNode* pos) 
{

    assert(pos);
    pos->prev->next = pos->next;
    pos->next->prev = pos->prev;

    free(pos);
    pos = NULL;
}

// 查找指定值的节点
LTNode* LTFind(LTNode* phead, LTDatatype x) 
{

    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        if (pcur->data == x) 
        {
            return pcur;
        }
        pcur = pcur->next;
    }
    return NULL;
}


// 对双链表去重函数
void ListRemoveDuplicates(LTNode* phead) 
{
    if (phead == NULL) 
    {
        return;
    }

    LTNode* pcur = phead->next;
    while (pcur != phead) 
    {
        LTNode* pnext = pcur->next;
        LTNode* prev = pcur->prev;
        LTNode* finder = pcur->next;
        while (finder != phead) 
        {
            if (finder->data == pcur->data) 
            {
                prev->next = finder->next;
                finder->next->prev = prev;
                LTNode* temp = finder;
                finder = finder->next;
                free(temp);
            }
            else 
            {
                prev = finder;
                finder = finder->next;
            }
        }
        pcur = pnext;
    }
}
// 菜单函数
int menu() {
    int choose;
    printf("请选择对双链表的操作：\n");
    printf("1. 删除数据\n");
    printf("2. 插入数据\n");
    printf("3. 销毁双链表\n");
    printf("4. 查找数据\n");
    printf("5. 对双链表去重\n");
    printf("请输入你的选择：");
    scanf("%d", &choose);
    return choose;
}

// 插入数据菜单函数
int insmenu() {
    int choose;
    printf("请选择插入数据的方式：\n");
    printf("1. 头插\n");
    printf("2. 尾插\n");
    printf("3. 指定一个数之前插入\n");
    printf("请输入你的插入操作选择：\n");
    scanf("%d", &choose);
    return choose;
}

// 删除数据菜单函数
int delmenu() {
    int delchoice;
    printf("1. 在头部删除节点\n");
    printf("2. 在尾部删除节点\n");
    printf("3. 删除指定位置的节点\n");
    printf("4. 删除指定值的节点\n");
    printf("请输入你的删除操作选择: \n");
    scanf("%d", &delchoice);
    return delchoice;
}

test.c文件

#pragma warning(disable:4996)
#include"List.h"


int main() 
{
    LTNode* plist = LTInit();
    int num;
    printf("请输入双链表的节点个数：");
    scanf("%d", &num);
    printf("请依次输入双链表的节点值：\n");

    for (int i = 0; i < num; i++) 
    {
        int value;
        scanf("%d", &value);
        LTPushBack(plist, value);
    }

    printf("初始化后的双链表为：\n");
    LTPrint(plist);

    int input;
    LTNode* find;
    int value;

    do {
        input = menu();
        switch (input) 
        {
        case 1: 
        {
            int delchoice = delmenu();
            switch (delchoice) 
            {
            case 1:
                if (!LTEmpty(plist)) 
                {
                    LTPopFront(plist);
                }
                break;
            case 2:
                if (!LTEmpty(plist)) 
                {
                    LTPopBack(plist);
                }
                break;
            case 3: {
                printf("请输入要删除节点的位置：");
                int pos;
                scanf("%d", &pos);
                LTNode* pcur = plist->next;
                for (int i = 0; i < pos; i++) 
                {
                    pcur = pcur->next;
                }
                LTErase(pcur);
                break;
            }
            case 4: 
            {
                printf("请输入要删除的值：");
                scanf("%d", &value);
                find = LTFind(plist, value);
                if (find != NULL) 
                {
                    LTErase(find);
                }
                break;
            }
            default:
                printf("无效的删除操作选择\n");
                break;
            }
            break;
        }
        case 2: 
        {
            int inschoice = insmenu();
            switch (inschoice) 
            {
            case 1:

                printf("请输入要插入的值：");
                scanf("%d", &value);
                LTPushFront(plist, value);
                break;
            case 2:

                printf("请输入要插入的值：");
                scanf("%d", &value);
                LTPushBack(plist, value);
                break;
            case 3: 
                {
                printf("请输入指定的数：");
                scanf("%d", &value);
                find = LTFind(plist, value);
                if (find != NULL) 
                {
                    printf("请输入要插入的值：");
                    scanf("%d", &value);
                    LTInsert(find, value);
                }
                else 
                {
                    printf("未找到指定的数\n");
                }
                break;
            }
            default:
                printf("无效的插入操作选择\n");
                break;
            }
            break;
        }
        case 3:
            LTDesTroy(plist);
            plist = NULL;
            break;
        case 4:
            printf("请输入要查找的值：");
            scanf("%d", &value);
            find = LTFind(plist, value);
            if (find != NULL) {
                printf("找到了，该值所在节点的下一个节点数据为：%d\n", find->next->data);
            }
            else 
            {
                printf("未找到指定的值\n");
            }
            break;
        case 5:
            ListRemoveDuplicates(plist);
            break;
        default:
            printf("无效的操作选择\n");
            break;
        }


        if (plist != NULL) 
        {
            LTPrint(plist);
        }
    } while (input != 3);

    return 0;
}

非常感谢您的阅读，喜欢的话记得三连哦

在这里插入图片描述

原文地址：https://blog.csdn.net/2402_83322742/article/details/143914004

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【Kafka 实战】Kafka 如何保证消息的顺序性？
下一篇：（二）Ubuntu22.04+Stable-Diffusion-webui AI绘画中英双语插件安装

Windows电脑本地部署llamafile并接入Qwen大语言模型远程AI对话实战
Windows电脑本地部署llamafile并接入Qwen大语言模型远程AI对话实战
阅读更多2024-11-23
解决vm虚拟机中ctrl键粘滞问题（一直处于按下状态）
虚拟机中点击鼠标左键没有问题，单独按下键盘也没有问题，但是如果按下键盘的同时在按下鼠标左键就会卡住。而且100%稳定复现。发现问题原因：vm版本的问题，我的版本是17.5.0，升级成17.5.2 bu
阅读更多2024-11-23
第十章 JavaScript的应用
10.1.1 JavaScript简介1 简单性JavaScript 设计之初就考虑到了非专业程序员的使用，因此它的语法相对简单，容易上手。2 动态性JavaScript 是一种解释型语言，代码可以在
阅读更多2024-11-23
非root用户安装CUDA
4.下载完成后执行.run文件，需要添加两个参数，一个是--override，用于跳过某些检查或限制；另一个是--toolkitpath，它表示安装路径，必须是自己目录下面的路径，如果是根目录就会安装
阅读更多2024-11-23
Python操作neo4j库py2neo使用之py2neo 删除及事务相关操作（三）
【代码】## Python操作neo4j库py2neo使用之py2neo 删除及事务相关操作（三）
阅读更多2024-11-23
【通俗理解】Jensen不等式与变分分布q(z)在积分计算中的应用
Jensen不等式 #变分分布 #积分计算 #期望 #凸函数 #优化问题 #下界估计 #机器学习。
阅读更多2024-11-23
「Mac玩转仓颉内测版27」基础篇7 - 字符串类型详解
本篇将介绍 Cangjie 中的字符串类型，包括字符串的定义、字面量形式、插值表达、常用操作及应用场景，帮助开发者熟练掌握字符串的使用。
阅读更多2024-11-23
数据科学与SQL：组距分组分析 | 区间分布问题
绝对值分布分析也可以理解为组距分组分析。对于某个指标而言，一个记录对应的指标值的绝对值，肯定落在所有指标值的绝对值的最小值和最大值构成的区间内，根据一定的算法，在把这个区间划分为等距离的几个小区间，，
阅读更多2024-11-23
c++编译报C1004错误的原因及解决办法
可能是你的代码文件最后没有正确的结束符，或者是缺少了一些必要的头文件或语句。默认磁盘驱动器没有足够的空间用于临时文件，需要大约两倍于源文件的空间。编译器到达了源文件尾但未解析构造。计算结果为假的 #i
阅读更多2024-11-23
mysql 去重补全取出重复变量函数和存储过程
mysql 去重补全取出重复变量函数和存储过程
阅读更多2024-11-23

深度探索 C 语言数据结构——双链表：从键盘输入到增删查改及去重操作全解析

C 语言数据结构——双链表：从键盘输入到增删查改及去重操作全解析

例题

一、创建双链表

（一）定义双链表

（二）双链表的创建函数

二、双链表的增加操作

（一）头插

（二）尾插

（三）在pos位置之后插入数据

三、双链表的删除操作

（一）头删

（二）尾删

（三）删除指定位置节点

四、双链表去重操作

五、销毁双链表

六、菜单函数的实现

七、主函数的实现

八、本文的所有源代码

List.h文件

List.c文件

test.c文件

相关文章