【C 数据结构】单链表

news2024/12/24 21:47:47

文章目录

  • 【 1. 基本原理 】
    • 1.1 链表的节点
    • 1.2 头指针、头节点、首元节点
  • 【 2. 链表的创建 】
    • 2.0 创建1个空链表（仅有头节点）
    • 2.1 创建单链表（头插入法）*
    • 2.2 创建单链表（尾插入法）
  • 【 3. 链表插入元素 】
  • 【 4. 链表删除元素 】
  • 【 5. 链表查找元素 】
  • 【 6. 链表修改元素 】
  • 【 7. 链表输出 】
  • 【 8. 实例 - 链表元素的增删查改 】
  • 【 9. 无头节点的链表 】

本文中若未指定，则默认链表存在首元结点。

【 1. 基本原理 】

  • 与顺序表不同，链表 不限制数据的物理存储状态（存储空间是否连续） ，使用链表存储的数据元素，其 物理存储位置是随机的 。
  • 例如，使用链表存储 1,2,3 ，数据的物理存储状态如图所示：
  • 上图根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的直接后继元素：
    在这里插入图片描述
  • 数据元素随机存储，并通过指针表示数据之间逻辑关系 的存储结构就是 链式存储结构。

1.1 链表的节点

  • 链表中每个数据的存储都由以下两部分组成：
    • 数据元素本身，其所在的区域称为数据域；
    • 指向直接后继元素的指针，所在的区域称为指针域；
  • 链表中存储各数据元素的结构，即 节点。如图所示：
    在这里插入图片描述
  • 也就是说， 链表实际存储的是一个一个的节点，真正的数据元素包含在这些节点中，如图所示：
    在这里插入图片描述
  • 链表中每个节点的具体实现，需要使用 C 语言中的结构体， 每个节点都是一个结构体，具体实现代码为：
    • 由于指针域中的指针要指向的也是一个节点，因此要声明为 Link 类型（这里要写成 struct Link* 的形式）。
//定义结点类型
typedef struct Node {
    int data;       //数据类型，你可以把int型的data换成任意数据类型，包括结构体struct等复合类型
    struct Node *next;          //单链表的指针域
} Node,*LinkedList;  
//Node表示结点的类型，LinkedList表示指向Node结点类型的指针类型

1.2 头指针、头节点、首元节点

  • 一个完整的链表需要由以下几部分构成：
    • 头指针：一个普通的指针，它的特点是 永远指向链表第一个节点的位置。很明显，头指针用于指明链表的位置，便于后期找到链表并使用表中的数据；
    • 节点：链表中的节点又细分为头节点、首元节点和其他节点：
      • 头节点：其实就是一个 不存任何数据的空节点，通常作为链表的第一个节点。对于链表来说，头节点不是必须的，它的作用只是为了方便解决某些实际问题；链表中有头节点时，头指针指向头节点；反之，若链表中没有头节点，则头指针指向首元节点。
      • 首元节点：由于头节点（也就是空节点）的缘故，链表中称 第一个存有数据的节点 为首元节点。首元节点只是对链表中第一个存有数据节点的一个称谓，没有实际意义；
      • 其他节点：链表中其他的节点。
  • 一个存储 {1,2,3} 的完整链表结构如图所示：
    在这里插入图片描述
  • 节点的创建，C实现：
Node *p=(Node *)malloc(sizeof(Node));

//或者 Node* L = new Node;

【 2. 链表的创建 】

  • 创建一个链表需要做如下工作：
    • 声明一个头指针（如果有必要，可以声明一个头节点）；
    • 创建多个存储数据的节点，在创建的过程中，要随时与其前驱节点建立逻辑关系；

2.0 创建1个空链表（仅有头节点）

  • 创建一个指向链表节点的指针，申请一块链表节点的内存，使该指针指向该块内存（若该指针指向空，表示内存申请失败，输出信息提示），最后将该指针指向的节点的指针域指向NULL空，表示该链表初始化后仅有1个节点。
Node* listinit(){
    Node *L;
    L=(Node*)malloc(sizeof(Node));      //开辟空间 
    if(L==NULL){                     //判断是否开辟空间失败，这一步很有必要
        printf("申请空间失败");
        exit(0);                  //开辟空间失败可以考虑直接结束程序
    }
    L->next=NULL;       //指针指向空
    return L;
}

2.1 创建单链表（头插入法）*

  • 先创建一个头节点，头节点的指针域指向空。插入新节点时，将新节点的指针域指向头节点的next，再将头节点的next指向该新节点。
    在这里插入图片描述
  • C 实现
//单链表的建立1，头插法建立单链表
LinkedList LinkedListCreatH(int x[],int N) {
    Node* L;
    L = (Node*)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                      //初始化一个空链表

    for(int i=0;i<N;++i){
        Node* p;
        p = (Node*)malloc(sizeof(Node));   //申请新的结点
        p->data = x[i];                     //结点数据域赋值
        p->next = L->next;                    //将结点插入到表头L-->|2|-->|1|-->NULL
        L->next = p;
    }
    return L;
}

2.2 创建单链表（尾插入法）

  • 先创建一个头节点，头节点的指针域指向空，再创建一个尾指针，尾指针先指向头节点。插入新节点时，将尾指针的next指向该新节点，再将尾指针指向该新节点，最后将尾指针的next指空。
    在这里插入图片描述
  • C实现：
//单链表的建立2，尾插法建立单链表
LinkedList LinkedListCreatT(int x[], int N) {
    Node* L;
    L = (Node*)malloc(sizeof(Node)); //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node* r;
    r = L;                          //r始终指向尾节点，开始时指向头节点
    for (int i = 0; i < N; ++i) {
        Node* p;
        p = (Node*)malloc(sizeof(Node));   //申请新的结点
        p->data = x[i];                     //结点数据域赋值
        r->next = p;                 //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;

    return L;
}

【 3. 链表插入元素 】

  • 链表插入元素只需做以下两步操作，即可将新元素插入到指定的位置：
    1.将新结点的 next 指针指向插入位置后的结点；
    2.将插入位置前结点的 next 指针指向插入结点；
  • 链表插入元素的操作必须是先步骤 1，再步骤 2；反之，若先执行步骤 2 即 将插入位置前结点的 next 指针指向插入结点，除非再添加一个指针，作为插入位置后续链表的头指针，否则会导致插入位置后的这部分链表丢失，无法再实现步骤 1。
  • 例如，我们在链表 1,2,3,4 的基础上分别实现在头部、中间部位、尾部插入新元素 5，其实现过程如图所示：
    在这里插入图片描述
  • 从图中可以看出，虽然新元素的插入位置不同，但实现插入操作的方法是一致的，都是先执行步骤 1 ，再执行步骤 2。
  • C 实现：指定位置插入元素
//单链表的插入
//在链表的第i个位置插入x的元素，若位置超过链表大小，则链表不改动
LinkedList LinkedListInsert(LinkedList L, int i, int x) {
    Node* pre;  // pre为前驱结点
    pre = L;
    int j = 1;
    while (pre->next) {
        if (i == j++) {
            Node* p;  //插入的结点为p
            p = (Node*)malloc(sizeof(Node));
            p->data = x;
            p->next = pre->next;
            pre->next = p;
            break;
        }
        pre = pre->next;
    }   
    return L;
}

【 4. 链表删除元素 】

  • 从链表中删除指定数据元素时，实则就是将存有该数据元素的节点从链表中摘除，但作为一名合格的程序员，要对存储空间负责，对不再利用的存储空间要及时释放 。因此，从链表中删除数据元素需要进行以下 2 步操作：
    • 将要删除的节点的前一个节点的next指向要删除节点的next；
    • 可选：手动释放掉要删除节点的内存。

例如，从存有 1,2,3,4 的链表中删除元素 3，则此代码的执行效果如图所示：
在这里插入图片描述

  • C 实现：删除指定元素的节点
// 删除单链表中值为x的元素
// 若有相同元素值，默认删除离表头最近的元素
// 若链表不存在x，则链表不改动
LinkedList LinkedListDelete(LinkedList L, int x) {
    Node* p, * pre;                   //pre为前驱结点，p为查找的结点。
    p = L->next;
    pre = L;
    while (p) 
    {
        if (p->data == x)
        {
            pre->next = p->next;  //删除操作，将其前驱next指向其后继。
            free(p);
            break;
        }
        pre = p;
        p = p->next;
    }
    return L;
}
  • C实现：删除指定位置的节点
//p为原链表，add为要删除元素的位置
Node *delElem(Node * p, int add)
{
    Node * temp = p;
    //遍历到被删除结点的上一个结点
    for (int i = 1; i < add; i++)
    {
        temp = temp->next;
        if (temp->next == NULL)
        {
            printf("没有该结点\n");
            return p;
        }
    }
    Node * del = temp->next;//单独设置一个指针指向被删除结点，以防丢失
    temp->next = temp->next->next;//删除某个结点的方法就是更改前一个结点的指针域
    free(del);//手动释放该结点，防止内存泄漏
    return p;
}

【 5. 链表查找元素 】

  • 从首元结点依次遍历表中节点，用被查找元素与各节点数据域中存储的数据元素进行比对，直至比对成功或遍历至链表最末端的 NULL（比对失败的标志）。
  • C 实现：查找指定值的元素位置
// 查找单链表中的元素
// p为原链表，elem表示被查找元素，函数返回被查元素的位置，若返回值为-1表示链表中不存在该元素
int selectElem(Node* p, int elem)
{
    //新建一个指针t，初始化为头指针 p
    Node* t = p;
    int i = 1;
    //由于头节点的存在，因此while中的判断为t->next
    while (t->next)
    {
        t = t->next;
        if (t->data == elem)
            return i;
        i++;
    }
    //程序执行至此处，表示查找失败
    printf("该数据不存在\n");
    return -1;
}

【 6. 链表修改元素 】

  • 更新链表中的元素，只需通过遍历找到存储此元素的节点，对节点中的数据域做更改操作即可。
  • C 实现：修改指定位置的元素
//add 表示更改结点在链表中的位置，newElem 为新的数据域的值
Node *amendElem(Node * p,int add,int newElem)
{
    Node  * temp=p;
    temp=temp->next;//在遍历之前，temp指向首元结点
    //遍历到待更新结点
    for (int i=1; i<add; i++) 
        temp=temp->next;
    temp->elem=newElem;
    return p;
}
  • C 实现：修改指定元素值
//将链表中值为x的元素全都变为k。
LinkedList LinkedListReplace(LinkedList L, int x, int k) {
    Node* p = L->next;
    int i = 0;
    while (p) {
        if (p->data == x) {
            p->data = k;
        }
        p = p->next;
    }
    return L;
}

【 7. 链表输出 】

  • 首先创建一个链表节点的指针，指向首元结点，然后判断该指针是否指向了空，若非空，则输出该指针指向的节点的信息，然后指针指向下一个节点循环判断，直到该指针为空。
//输出单链表
void printList(LinkedList L){
    Node *p=L->next;
    int i=0;
    while(p){
        printf("第%d个元素的值为:%d\n",++i,p->data);
        p=p->next;
    }
}

【 8. 实例 - 链表元素的增删查改 】

  • 对链表中数据元素做"增删查改"的实现过程及 C 语言代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

//定义结点类型
typedef struct Node
{
    int data;           //数据类型，可以把int型的data换成任意数据类型，包括结构体struct等复合类型
    struct Node* next;  //单链表的指针域
} Node, * LinkedList;


//建立单链表，尾插法
LinkedList LinkedListCreatT(int x[], int N) {
    Node* L;
    L = (Node*)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node* r;
    r = L;                          //r始终指向终端结点，开始时指向头结点
    for (int i = 0; i < N; ++i) {
        Node* p;
        p = (Node*)malloc(sizeof(Node));   //申请新的结点
        p->data = x[i];                     //结点数据域赋值
        r->next = p;                 //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;

    return L;
}

// 查找单链表中的元素
// p为原链表，elem表示被查找元素，函数返回被查元素的位置，若返回值为-1表示链表中不存在该元素
int selectElem(Node* p, int elem)
{
    //新建一个指针t，初始化为头指针 p
    Node* t = p;
    int i = 1;
    //由于头节点的存在，因此while中的判断为t->next
    while (t->next)
    {
        t = t->next;
        if (t->data == elem)
            return i;
        i++;
    }
    //程序执行至此处，表示查找失败
    printf("该数据不存在\n");
    return -1;
}

//单链表的插入
//在链表的第i个位置插入x的元素，若位置超过链表大小，则链表不改动
LinkedList LinkedListInsert(LinkedList L, int i, int x) {
    Node* pre;                      //pre为前驱结点
    pre = L;
    int j = 1;
    while (pre->next) {
        if (i == j++) {
            Node* p;  //插入的结点为p
            p = (Node*)malloc(sizeof(Node));
            p->data = x;
            p->next = pre->next;
            pre->next = p;
            break;
        }
        pre = pre->next;
    }   
    return L;
}

// 删除单链表中值为x的元素
// 若有相同元素值，默认删除离表头最近的元素
// 若链表不存在x，则链表不改动
LinkedList LinkedListDelete(LinkedList L, int x) {
    Node* p, * pre;                   //pre为前驱结点，p为查找的结点。
    p = L->next;
    pre = L;
    while (p) 
    {
        if (p->data == x)
        {
            pre->next = p->next;  //删除操作，将其前驱next指向其后继。
            free(p);
            break;
        }
        pre = p;
        p = p->next;
    }
    return L;
}

//将链表中值为x的元素全都变为k。
LinkedList LinkedListReplace(LinkedList L, int x, int k) {
    Node* p = L->next;
    int i = 0;
    while (p) {
        if (p->data == x) {
            p->data = k;
        }
        p = p->next;
    }
    return L;
}

//输出单链表
void printList(LinkedList L) {
    Node* p = L->next;
    int i = 0;
    while (p) 
    {
        printf("第%d个元素的值为:%d\n", ++i, p->data);
        p = p->next;
    }
}

int main() {
    int N;
    printf("请输入链表的数量：");
    scanf("%d", &N);
    printf("请输入链表的元素：");
    int *x=new int[N];
    for (int i = 0; i < N; ++i)
        scanf("%d",&x[i]);
    
    //创建
    LinkedList list;
    list = LinkedListCreatT(x,N);
    printList(list);

    //插入 
    int pos;
    int data;
    printf("请输入插入数据的位置：");
    scanf("%d", &pos);
    printf("请输入插入数据的值：");
    scanf("%d", &data);
    LinkedListInsert(list, pos, data);
    printList(list);

    //查找
    printf("请输入查找数据的值：");
    scanf("%d", &data);
    printf("该数据在链表中的位置为%d\n",selectElem(list, data));

    //修改
    int newdata;
    printf("请输入修改的数据：");
    scanf("%d", &data);
    printf("请输入修改后的值：");
    scanf("%d", &newdata);
    LinkedListReplace(list, data, newdata);
    printList(list);

    //删除 
    printf("请输入要删除的元素的值：");
    scanf("%d", &data);
    LinkedListDelete(list, data);
    printList(list);

    return 0;
}

在这里插入图片描述
在这里插入图片描述

【 9. 无头节点的链表 】

  • 创建一个无头节点的链表，C 实现：
//创建1个有头节点的单链表
Node* LinkedListCreatN(int x[], int N) {
    Node* L = (Node*)malloc(sizeof(Node));
    L->data = x[0];
    L->next = NULL;
    Node* p = L; //p作为尾节点指针
    for (int i = 1; i < N; ++i) {
        Node *temp = (Node *) malloc(sizeof(Node));
        temp->data = x[i];
        temp->next = NULL;
        p->next = temp;
        p = temp;
    }
    return L;
}
  • 输出无头节点的单链表各个元素，C实现：
//输出单链表
void printList(LinkedList L) {
    Node* p = L;
    int i = 0;
    while (p) 
    {
        printf("第%d个元素的值为:%d\n", ++i, p->data);
        p = p->next;
    }
}
  • 删除无头节点的单链表的指定元素，C实现：
    当删除的元素是第一个节点时，为了方便处理，这里事先申请一块内存，该内存的next指针域指向该链表的头节点，相当于作为 pre 前指针。
//删除链表中第一个值为x的元素
Node*  DeleteList(Node* L, int x) {
    Node* temptou = (Node*)malloc(sizeof(Node));
    temptou->next = L;

    Node* pre=temptou;
    Node* cur=pre->next;

    while (cur)
    {
        if (cur->data == x) {
            pre->next = cur->next;
            free(cur);
            break;
        }
        pre = cur;
        cur = cur->next;
    }
    return temptou->next;
}
  • 实例
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

//定义结点类型
typedef struct Node
{
    int data;           //数据类型，可以把int型的data换成任意数据类型，包括结构体struct等复合类型
    struct Node* next;  //单链表的指针域
} Node;


//创建1个有头节点的单链表
Node* LinkedListCreatN(int x[], int N) {
    Node* L = (Node*)malloc(sizeof(Node));
    L->data = x[0];
    L->next = NULL;
    Node* p = L; //p作为尾节点指针
    for (int i = 1; i < N; ++i) {
        Node* temp = (Node*)malloc(sizeof(Node));
        temp->data = x[i];
        temp->next = NULL;
        p->next = temp;
        p = temp;
    }
    return L;
}

//删除链表中第一个值为x的元素
Node*  DeleteList(Node* L, int x) {
    Node* temptou = (Node*)malloc(sizeof(Node));
    temptou->next = L;

    Node* pre=temptou;
    Node* cur=pre->next;

    while (cur)
    {
        if (cur->data == x) {
            pre->next = cur->next;
            free(cur);
            break;
        }
        pre = cur;
        cur = cur->next;
    }
    return temptou->next;
}

//输出单链表
void printList(Node* L) {
    Node* p = L;
    int i = 0;
    while (p)
    {
        printf("第%d个元素的值为:%d\n", ++i, p->data);
        p = p->next;
    }
}

int main() {
    int N;
    printf("请输入链表的元素数量：");
    scanf("%d", &N);
    printf("请输入链表的元素：");
    int* x = new int[N];
    for (int i = 0; i < N; ++i)
        scanf("%d", &x[i]);

    //创建
    Node* list;
    list = LinkedListCreatN(x, N);
    printList(list);

    //删除
    int data;
    printf("请输入要删除的元素值：");
    scanf("%d",&data);
    Node* listtemp;
    listtemp = DeleteList(list, data);
    printList(listtemp);

    return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1601566.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

rabbitmq每小时自动重启

rabbitmq每小时自动重启

引言 找了半天&#xff0c;最后通过系统日志发现是因为执行 systemctl restart rabbitmq-server 命令无法返回回调 systemctl 导致超时&#xff0c;自动关机。怀疑是 rabbitmq 与 systemctl 冲突&#xff0c;后 mq 升级版本已修复&#xff0c;可参考&#xff1a;https://github…
阅读更多...
golang-基础语法

golang-基础语法

make 和 new 的区别 make 和 new 都是用来分配内存 make 只能对 slice map channel 进行初始化结构体实例。new 可以对任意类型进行初始化make 用于分配数据对象的具体实例&#xff0c;new 用于分配数据类型的默认值&#xff0c;并返回该数据的指针。 new 出来的 slice 、ma…
阅读更多...
springboot Logback 不同环境，配置不同的日志输出路径

springboot Logback 不同环境，配置不同的日志输出路径

1.背景&#xff1a; mac 笔记本开发&#xff0c;日志文件写到/data/logs/下&#xff0c;控制台报出&#xff1a;Failed to create parent directories for [/data/logs/........... 再去手动在命令窗口创建文件夹data&#xff0c;报Read-only file system 2.修改logback-spri…
阅读更多...
(C++) 稀疏表Sparse Table

(C++) 稀疏表Sparse Table

目录 一、介绍 1.1 倍增 1.2 稀疏表ST 二、原理 三、代码实现 3.1 创建稀疏表 3.2 初始化数值 3.3 ST查询 一、介绍 1.1 倍增 倍增的思想是在数据空间特别大的时候&#xff0c;快速进行查找搜索而使用的。例如想要在一个数据量为n的递增数组中查找到等于x的下标&#x…
阅读更多...
算法|基础算法|高精度算法

算法|基础算法|高精度算法

基础算法|位运算 1.高精度加法 2.高精度减法 3.高精度乘法 4.高精度除法 心有猛虎&#xff0c;细嗅蔷薇。你好朋友&#xff0c;这里是锅巴的C\C学习笔记&#xff0c;常言道&#xff0c;不积跬步无以至千里&#xff0c;希望有朝一日我们积累的滴水可以击穿顽石。 高精度加法 …
阅读更多...
图灵奖得主AviWigderson：随机性与AI深度融合，引领计算科学新篇章

图灵奖得主AviWigderson：随机性与AI深度融合，引领计算科学新篇章

近日&#xff0c;理论计算机科学领域的杰出代表Avi Wigderson教授荣获了享有“计算机界诺贝尔奖”美誉的图灵奖&#xff0c;以表彰他对计算中随机性和伪随机性研究的杰出贡献。这一荣誉不仅彰显了Wigderson教授在计算理论领域的卓越成就&#xff0c;也为当前热门的AI和深度学习…
阅读更多...
打破常规，重新定义PMP备考之路

打破常规，重新定义PMP备考之路

今天我想和大家聊聊一个我们都不陌生的话题——PMP备考。你是不是也在备考的苦海中挣扎&#xff0c;或是听说过各种“速成”的神话&#xff1f;&#x1f914; 最近读到一篇文章&#xff08;来着圣略PMP培训讲师老杨&#xff09;&#xff0c;让我对PMP备考有了新的认识。原来&a…
阅读更多...
如何用flutter写一个好的登录页面

如何用flutter写一个好的登录页面

编写一个好的登录页面是构建用户友好且安全的移动应用的重要一步。下面是使用Flutter编写一个好的登录页面的一些建议和步骤&#xff1a; 1. 设计用户界面 1.简洁明了的布局&#xff1a;确保界面简洁明了&#xff0c;不要过分复杂&#xff0c;避免用户感到困惑。 2.清晰的输入框…
阅读更多...
1、IPEX-LLM(原名BigDL-LLM)环境配置

1、IPEX-LLM(原名BigDL-LLM)环境配置

IPEX-LLM 是一个为Intel XPU (包括CPU和GPU) 打造的轻量级大语言模型加速库&#xff0c;在Intel平台上具有广泛的模型支持、最低的延迟和最小的内存占用。 您可以使用 IPEX-LLM 运行任何 PyTorch 模型&#xff08;例如 HuggingFace transformers 模型&#xff09;。在运行过程中…
阅读更多...
Redis的IO模型 和 多线程问题

Redis的IO模型 和 多线程问题

Redis中的线程和IO模型 什么是Reactor模式 &#xff1f;单线程Reactor模式流程单线程Reactor&#xff0c;工作者线程池多Reactor线程模式 Redis中的线程和IO概述socketI/O多路复用程序文件事件分派器文件事件处理器文件事件的类型总结 多线程问题1. Redis6.0之前的版本真的是单…
阅读更多...
05节-51单片机-模块化编程

05节-51单片机-模块化编程

1.两种编程方式的对比 传统方式编程&#xff1a; 所有的函数均放在main.c里&#xff0c;若使用的模块比较多&#xff0c;则一个文件内会有很多的代码&#xff0c;不利于代码的组织和管理&#xff0c;而且很影响编程者的思路 模块化编程&#xff1a; 把各个模块的代码放在不同的…
阅读更多...
学习java时候的笔记(十六)

学习java时候的笔记(十六)

常用API Math 是一个帮助我们用于进行数学计算的工具类 Math中常用的方法 方法名说明abs(int a)获取参数的绝对值abs(-1) > 1ceil(double b)向上取整1.1 > 2floor(double b)向下取整1.7>1round(float a)四舍五入max(int a, int b)取两个整数的最大值max(2,3) >…
阅读更多...
LeetCode-924. 尽量减少恶意软件的传播【深度优先搜索 广度优先搜索 并查集 图 哈希表】

LeetCode-924. 尽量减少恶意软件的传播【深度优先搜索 广度优先搜索 并查集 图 哈希表】

LeetCode-924. 尽量减少恶意软件的传播【深度优先搜索 广度优先搜索 并查集 图 哈希表】 题目描述&#xff1a;解题思路一&#xff1a;解题思路二&#xff1a;0解题思路三&#xff1a;0 题目描述&#xff1a; 给出了一个由 n 个节点组成的网络&#xff0c;用 n n 个邻接矩阵图…
阅读更多...
02_对象树

02_对象树

#include "mypushbutton.h" #include <QDebug>MyPushButton::MyPushButton(QWidget *parent): QPushButton(parent) {qDebug()<<"我的按钮类构造调用"; }MyPushButton::~MyPushButton() {qDebug()<<"我的按钮类析构调用"; }交…
阅读更多...
「JavaEE」线程

「JavaEE」线程

&#x1f387;个人主页&#xff1a;Ice_Sugar_7 &#x1f387;所属专栏&#xff1a;JavaEE &#x1f387;欢迎点赞收藏加关注哦&#xff01; 线程 &#x1f349;线程&#x1f34c;多线程&#x1f34c;线程与进程的联系&区别&#x1f34c;多线程编程&#x1f34c;创建线程&a…
阅读更多...
spring02：DI（依赖注入）

spring02：DI（依赖注入）

spring02&#xff1a;DI&#xff08;依赖注入&#xff09; 文章目录 spring02&#xff1a;DI&#xff08;依赖注入&#xff09;前言&#xff1a;一、构造器注入&#xff08;constructor&#xff09;二、set注入&#xff1a;分析&#xff1a; 1. Student类&#xff1a;2. Addres…
阅读更多...
【大语言模型】轻松本地部署Stable Diffusion

【大语言模型】轻松本地部署Stable Diffusion

硬件要求&#xff1a; 配备至少8GB VRAM的GPU&#xff0c;如果你的电脑只有CPU&#xff0c;请看到最后。根据部署规模&#xff0c;需要足够的CPU和RAM。 软件要求&#xff1a; Python 3.7或更高版本。支持NVIDIA GPU的PyTorch。Hugging Face的Diffusers库。Hugging Face的Tr…
阅读更多...
什么是神经网络和机器学习？【云驻共创】

什么是神经网络和机器学习？【云驻共创】

什么是神经网络和机器学习&#xff1f; 一.背景 在当今数字化浪潮中&#xff0c;神经网络和机器学习已成为科技领域的中流砥柱。它们作为人工智能的支柱&#xff0c;推动了自动化、智能化和数据驱动决策的进步。然而&#xff0c;对于初学者和专业人士来说&#xff0c;理解神经…
阅读更多...
WordPress 告别 MySQL：Docker SQLite WordPress

WordPress 告别 MySQL：Docker SQLite WordPress

本篇文章聊聊&#xff0c;如何将这个持续诞生和维护了 21 年的开源软件“脱离数据库”运行&#xff0c;让它能够更加轻量、适合低成本离线运行。 写在前面 2003 年&#xff0c;Michel Valdrighi 基于 b2/cafelog 创建了开源软件 WordPress&#xff0c;并在 GPL 协议下发布。 …
阅读更多...
【Java EE】关于Spring MVC 响应

【Java EE】关于Spring MVC 响应

文章目录 &#x1f38d;返回静态页面&#x1f332;RestController 与 Controller 的关联和区别&#x1f334;返回数据 ResponseBody&#x1f38b;返回HTML代码片段&#x1f343;返回JSON&#x1f340;设置状态码&#x1f384;设置Header&#x1f338;设置Content-Type&#x1f…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023