02线性表 - 链表

这里是只讲干货不讲废话的炽念，这个系列的文章是为了我自己以后复习数据结构而写，所以可能会用一种我自己能够听懂的方式来描述，不会像书本上那么枯燥和无聊，且全系列的代码均是可运行的代码，关键地方会给出注释^_^

全文1W+字

版本：C++17

编译器：Clion 2023.3.24

暂时只给出代码，不会涉及到基础知识的讲解

 1.链表的定义

1.1定义链表结点

// 链表的核心是定义结点
typedef struct list_node{ // C语言中必须要先声明 list_node,不然编译器会报错，C++可以忽略这个问题
    Element value;                // 结点存储的数据元素
    struct list_node *next;       // 指向下一个结点的指针
}ListNode;

1.2定义链表头结点

// 链表的表头
typedef struct {
    ListNode head;        // 头结点,通常不存储实际数据,用作链表的起始点
    int len;              // 链表的长度,用于记录链表中实际结点的数量
}LinkList;

2.链表的实现函数

2.1.表的创建以及删除

// 创建链表和删除链表
LinkList *createLinkList();                   // 创建一个链表

void releaseLinkList(LinkList* linkList);     // 释放一个链表

2.2.向表中插入元素

// 三种插入方式
int insertLinkList(LinkList *linkList, int pos, Element val);   // 任意位置上插入

int headInsertLinkList(LinkList *linkList, Element val);        // 头插法

int tailInsertLinkList(LinkList *linkList, Element val);        // 尾插法

2.3.表的展示

void showLinkList(LinkList *linkList);                      // 显示链表内的元素

2.4.删除表中的元素

int deleteLinkList(LinkList *linkList, Element val);        // 删除链表中的特定元素

2.5逆转链表

void reverseLinklist(LinkList *linkList);                   // 逆转链表

3.实现函数的代码

3.1 createLinkList函数的实现

函数定义：
LinkList *createLinkList();

函数功能：
该函数用于创建一个空的链表，并返回链表的头结点指针

实现思路：
a.申请一个类型为LinkList，大小为sizeof(LinkList)的头结点

b.判空，判断申请是否成功

c.初始化LinkList->len = 0, LinkList->head.value = 0(根据实际情况来定义这个值)

d.初始化LinkList->head.next = NULL

e.返回指向新创建链表头结点的指针

具体实现代码：
LinkList *createLinkList() {
    LinkList *linkList = (LinkList *) malloc(sizeof (LinkList));
    if (!linkList){
        printf("Malloc linklist failed\n");
        return NULL;
    }

    linkList->len = 0;              // 表示链表的长度
    linkList->head.value = 0;       // 根据具体的场景来定义这个值
    linkList->head.next = NULL;

    printf("Create linklist success!\n");
    return linkList;
}

测试代码： 
int main(){
    LinkList *linkList= createLinkList();
    return 0;
}

测试结果： 

3.2 releaseLinkList函数的实现

函数定义：
void releaseLinkList(LinkList* linkList);
函数功能：
释放链表中的所有节点(包括头节点)，避免内存泄漏
实现思路：

方法一：头删法

a.初始化:
获取链表头结点地址并赋值给 node 指针。
node->next 指向待删除结点的下一个结点，用于备份


b.循环删除:
循环遍历链表，条件为 node->next 不为空。
使用 tmp 指针指向要删除的结点 (node->next)。
将 node 的 next 指针指向 tmp 的下一个结点 (tmp->next)，移除 tmp 指向的结点。
释放 tmp 指向的结点内存。
更新链表长度，减去 1


c.释放头结点:
循环结束后，释放头结点的内存

方法二：循环删除法

a.初始化: 
将 node 指针指向链表的头结点的下一个结点，准备开始遍历链表


b.循环删除:
使用 while 循环遍历链表，直到到达链表末尾。在循环中：
备份当前要删除的结点到 tmp 指针
将当前结点的 next 指针指向下一个结点，从而将 tmp 指向的结点从链表中移除
释放 tmp 指向的结点的内存
更新链表长度，减去 1


c.释放头结点: 
最后释放头结点的内存
具体实现代码：
方法一：头删法(不断删除头结点后的那个结点，直到为空)
void releaseLinkList1(LinkList *linkList) {
    if (linkList){
        ListNode *node = &linkList->head;
        // 不断的删除头结点的下一个指向，直到为空（头删法）
        while (node->next){
            ListNode *tmp = node->next; // 备份要删除的结点
            node->next = tmp->next;     // 这里为什么不是node = node->next;
            free(tmp);                  // 因为这样已经移动了头结点，会失去对前一个节点的引用，可能导致内存泄露
            linkList->len--;
        }

       
        printf("Release success! LinkList have %d node\n",linkList->len);
        free(linkList);
    }
}

方法二：循环删除法
void releaseLinkList2(LinkList *linkList){
    if (linkList) {
        ListNode *node = linkList->head.next;

        // 使用循环遍历链表，释放除头结点外的每个节点(循环删除法)
        while (node) {
            ListNode *tmp = node;           // 备份当前节点
            node = node->next;              // 移动到下一个节点
            free(tmp);                      // 释放当前节点
            linkList->len--;
        }

        printf("Release success! LinkList have %d node\n",linkList->len);
        free(linkList);
    }
}

测试代码：

因为需要知道链表中还剩下多少元素，所以先引入加入函数

1.头删法测试代码：
int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    insertLinkList(linkList, 2, 888);
    showLinkList(linkList);

    insertLinkList(linkList, 1, 888);
    showLinkList(linkList);

    tailInsertLinkList(linkList, 999);
    showLinkList(linkList);

    tailInsertLinkList(linkList, 111);
    showLinkList(linkList);

    releaseLinkList1(linkList);


    return 0;
}

2.循环删除法测试代码：
int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    insertLinkList(linkList, 2, 888);
    showLinkList(linkList);

    insertLinkList(linkList, 1, 888);
    showLinkList(linkList);

    tailInsertLinkList(linkList, 999);
    showLinkList(linkList);

    tailInsertLinkList(linkList, 111);
    showLinkList(linkList);

    releaseLinkList2(linkList);


    return 0;
}

测试结果：
1.头删法测试结果：

2.循环删除法测试结果：

 3.3 insertLinkList && headInsertLinkList && tailInsertLinkList 函数的实现

函数定义：
int insertLinkList(LinkList *linkList, int pos, Element val);   // 任意位置上插入

int headInsertLinkList(LinkList *linkList, Element val);        // 头插法

int tailInsertLinkList(LinkList *linkList, Element val);        // 尾插法
函数功能：

1.insertLinkList

在链表的指定位置插入新节点

 2.headInsertLinkList

在链表头部插入新节点

 3.tailInsertLinkList

 在链表尾部插入新节点
实现思路：

1.insertLinkList

a.判断链表是否为空，判断插入位置是否合法
 * 在 pos 的位置上插入，就要找到 pos-1 的位置
 * pos = 1 逻辑位置上的插入，就定义 cnt = 0 是头节点的位置
 * pos = 0 逻辑位置上的插入，就定义 cnt = -1 是头节点的位置

b.通过遍历找到待插入结点的前一个结点

c.判断 node 是否为空(逻辑完备性)

d.申请结点，将新节点 newNode->next 设为 NULL，将新节点的 value 设为 val

e.将 newNode->next 赋值为 node->next    //这两步一定要注意顺序

f.将 node->next 赋值为 newNode          //这两步一定要注意顺序

g.更新链表长度，LinkList->len++

2.headInsertLinkList

a.判断链表是否为空

b.申请结点，将新节点 newNode->next 设为 NULL，将新节点的 value 设为 val

c.将 newNode->next 赋值为 LinkList->head.next    //这两步一定要注意顺序

d.将 LinkList->head.next 赋值为 newNode->next    //这两步一定要注意顺序

e.更新链表长度，LinkList->len++

3.tailInsertLinkList

问：如何让尾插法达到O(1)的效率？

答：在定义链表头的时候增设尾指针，尾指针始终指向最后一个结点，即可实现O(1)的效率

a.判断链表是否为空

b.申请结点，将新节点 newNode->next 设为 NULL，将新节点的 value 设为 val

c.判断 LinkList 是否为只有头节点的链表

d.如果是只有头节点的链表，则直接插入到头节点后
    *即 LinkList->head.next = newNode;

e.如果不是，则不断循环找到尾节点，之后插入到尾节点后
    *即 node->next = newNode;

g.更新链表长度，LinkList->len++

具体实现代码：

1.insertLinkList

int insertLinkList(LinkList *linkList, int pos, Element val) {
    if (!linkList){
        printf("LinkList is null. Insert error!\n");
        return -1;
    }

    if (pos < 1 || pos > linkList->len + 1){
        printf("Insert position out of range!\n");
        return -1;
    }

    ListNode *node = &linkList->head;
    int cnt = 0;

    while (node && cnt < pos - 1){      // 找到待插入位置的前一个位置
        node = node->next;
        cnt++;
    }

    // 判断是找到了pos-1的位置，还是遍历完链表都没有找到
    if (node == NULL){                  // 为了逻辑完备性，多加一段代码
        printf("Insert position out of range!\n");
        return -1;
    }

    ListNode *newNode = (ListNode *) malloc(sizeof (ListNode)); //这段是核心代码
    newNode->next =  NULL;
    newNode->value = val;

    newNode->next = node->next;         // 这里注意顺序，一定要先保存当前结点的下一个结点的位置
    node->next = newNode;

    linkList->len++;
    return 0;
}

2.headInsertLinkList

int headInsertLinkList(LinkList *linkList, Element val) {
    if (!linkList){
        printf("LinkList is null. Insert error!\n");
        return -1;
    }

    ListNode *newNode = (ListNode *) malloc(sizeof (ListNode));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        return -1;
    }
    newNode->next = NULL;
    newNode->value = val;

    newNode->next = linkList->head.next;
    linkList->head.next = newNode;
    linkList->len++;

    return 0;
}

3.tailInsertLinkList

int tailInsertLinkList(LinkList *linkList, Element val) {
    if (!linkList) {
        printf("LinkList is null. Insert error!\n");
        return -1;
    }

    ListNode *newNode = (ListNode *) malloc(sizeof(ListNode));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        return -1;
    }
    newNode->value = val;
    newNode->next = NULL; // 初始化新节点的 next 指针为空

    if (linkList->head.next == NULL) { // 链表为空，直接将新节点插入到头节点
        linkList->head.next = newNode;
    } else {
        ListNode *node = linkList->head.next;
        while (node->next != NULL) { // 找到最后一个节点
            node = node->next;
        }
        node->next = newNode; // 将最后一个节点的 next 指向新节点
    }

    linkList->len++;
    return 0;
}
测试代码：

1.insertLinkList

int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    insertLinkList(linkList, 5, 888);
    showLinkList(linkList);

    insertLinkList(linkList, 2, 888);
    showLinkList(linkList);

    insertLinkList(linkList, 1, 888);
    showLinkList(linkList);

    insertLinkList(linkList,999, 888);
    showLinkList(linkList);

    releaseLinkList2(linkList);


    return 0;
}

 2.headInsertLinkList 

int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);
    
    releaseLinkList2(linkList);
    
    return 0;
}

 3.tailInsertLinkList

int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        tailInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    releaseLinkList2(linkList);

    return 0;
}

测试结果：

1.insertLinkList

 2.headInsertLinkList 

 3.tailInsertLinkList

3.4 void showLinkList(LinkList *linkList);

函数定义：
void showLinkList(LinkList *linkList);              // 显示链表内的元素

函数功能：
将链表中的所有元素依次打印到控制台
实现思路：
a.判断传入链表是否为空

b.定义 node 为头节点后的第一个节点

c.遍历链表，同时打印node->val，直到链表为空
具体实现代码：
void showLinkList(LinkList *linkList) {
    if (!linkList){
        printf("LinkList is null. Show error!\n");
        return;
    }

    ListNode *node = linkList->head.next;
    while (node){
        printf("%d ", node->value);
        node = node->next;
    }
    printf("\n");
}

测试代码： 
int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    releaseLinkList2(linkList);
    return 0;
}

测试结果：
 

3.5 deleteLinkList函数的实现

函数定义：
int deleteLinkList(LinkList *linkList, Element val)
函数功能：
从链表中删除第一个值为 val 的节点
实现思路：
a.判断传入的链表是否为空

b.用循环找到待删除节点的 前一个 结点

c.判断链表的下一个结点是否为空(逻辑完备性)

d.用一个指针 tmp 指向待删除的结点

e.将 node->next(待删除结点的前一个结点) 设为 tmp->next(删除结点的下一个结点)

f.释放掉 tmp 的空间

g.更新链表长度，LinkList->len--
具体实现代码：
int deleteLinkList(LinkList *linkList, Element val) {
    if (!linkList) {
        printf("LinkList is null. Delete error!\n");
        return -1;
    }

    ListNode *node = &linkList->head;
    while (node->next && node->next->value != val){
        node = node->next;
    }

    if (!node->next){
        printf("Find element failed! Delete failed!\n");
        return -1;
    }

    ListNode *tmp = node->next;        // 注意顺序
    node->next = tmp->next;
    free(tmp);
    linkList->len--;
    return 0;
}
测试代码：
int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    deleteLinkList(linkList, 104);
    showLinkList(linkList);

    deleteLinkList(linkList, 100);
    showLinkList(linkList);

    deleteLinkList(linkList, 104);
    showLinkList(linkList);

    deleteLinkList(linkList, 102);
    showLinkList(linkList);
    releaseLinkList2(linkList);
    return 0;
}
测试结果：

3.6 reverseLinklist函数的实现

函数定义：
void reverseLinklist(LinkList *linkList);
函数功能：
将给定的单链表反转
实现思路：

方法一：

a.判断当前链表是否为空

b.初始化 
cur = LinkList->head.next            (头节点的下一个)
pre = NULL
LinkList->head.next = NULL           (注意cur一定要在之前就要赋值)

c.循环
备份当前结点                          (pre = cur)
移动cur避免丢失                       (cur = cur->next)
将pre->next = LinkList->head.next    (不断往头节点后插入结点)
将 LinkList->head.next = pre         (将头节点指向正确的位置)

方法二：

a.判断当前链表是否为空

b.初始化 
cur = LinkList->head.next             (头节点的下一个)
nxt = NULL
LinkList->head.next = NULL            (注意cur一定要在之前就要赋值)

c.循环
备份下一个结点                         (nxt = cur->next)
将 cur->next = LinkList->head.next    (不断往头节点后插入结点)
将 LinkList->head.next = cur          (将头节点指向正确的位置)
cur = nxt                             (避免结点丢失)

方法三：

a. 将链表所有的结点全部压入到栈中(除了头节点)
b. 利用栈先进后出的特性，出栈一个元素，头节点就连接一个元素
c. 注意使用 尾插法 来连接元素

具体实现代码：

方法一(备份当前节点，反转当前结点)：

void reverseLinklist1(LinkList *linkList) {
    if (!linkList) {
        printf("LinkList is null. Delete error!\n");
        return;
    }

    ListNode *cur = linkList->head.next;
    ListNode *pre = NULL;
    linkList->head.next = NULL;

    while(cur){
        pre = cur;
        cur = cur->next;
        pre->next = linkList->head.next;
        linkList->head.next = pre;
    }

    printf("Reverse success!\n");
}

方法二(备份下一个结点，反转当前结点)：

void reverseLinklist2(LinkList *linkList) {
    if (!linkList) {
        printf("LinkList is null. Delete error!\n");
        return;
    }

    ListNode *cur = linkList->head.next;
    ListNode *nxt = NULL;
    linkList->head.next = NULL;

    while (cur){
        nxt = cur->next;
        cur->next = linkList->head.next;
        linkList->head.next = cur;
        cur = nxt;
    }

    printf("Reverse success!\n");
}

方法三：

这里在栈的部分写，到时候放一个链接

测试代码：

方法一：

int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    reverseLinklist1(linkList);
    
    releaseLinkList2(linkList);
    return 0;
}

方法二： 

int main(){
    LinkList *linkList= createLinkList();
    for (int i = 0; i < 5; i++){
        headInsertLinkList(linkList, i+100);
    }
    showLinkList(linkList);

    reverseLinklist2(linkList);

    releaseLinkList2(linkList);
    return 0;
}

测试结果：

方法一：


 

方法二：

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【时时三省】（C语言基础）函数和数组

【时时三省】（C语言基础）函数和数组

山不在高&#xff0c;有仙则名。水不在深&#xff0c;有龙则灵。 ——csdn时时三省 函数 跟数学里面的函数很相似 数组 一组相同类型的元素的集合 比如把5个整形1-5存起来 int arr&#xff3b;10&#xff3d;&#xff1d;&#xff5b;1&#xff0c;2&#xff0c;3&#x…
阅读更多...
逻辑门的题目怎么做？

逻辑门的题目怎么做？

FPGA语法练习——二输入逻辑门&#xff0c;一起来听~~ FPGA语法练习——二输入逻辑门 题目介绍&#xff1a;F学社-全球FPGA技术提升平台 (zzfpga.com)
阅读更多...
高功能自闭症：挑战与潜能并存

高功能自闭症：挑战与潜能并存

高功能自闭症是一种复杂的神经发育障碍&#xff0c;其患者通常在认知、语言和行为方面存在发育障碍&#xff0c;但保持相对正常的社交互动和自理能力。这种疾病由大脑神经发育异常引起&#xff0c;涉及神经递质、脑结构和功能连接等多个方面&#xff0c;导致信息处理和整合困难…
阅读更多...
WebRTC音视频-前言介绍

WebRTC音视频-前言介绍

目录 效果预期 1&#xff1a;WebRTC相关简介 1.1&#xff1a;WebRTC和RTC 1.2&#xff1a;WebRTC前景和应用 2&#xff1a;WebRTC通话原理 2.1&#xff1a;媒体协商 2.2&#xff1a;网络协商 2.3&#xff1a;信令服务器 效果预期 1&#xff1a;WebRTC相关简介 1.1&…
阅读更多...
SpringCloud的认识和初步搭建

SpringCloud的认识和初步搭建

目录 一.认识SpringCloud 二.SpringCloud的部署 2.1开发环境 2.2数据库的建立 2.3SpringCloud的部署 第一步&#xff1a; 创建Maven项目 第二步&#xff1a;完善pom文件 第三步&#xff1a;创建两个子项目 第四步&#xff1a;声明项目依赖以及构建插件 第五步&#xf…
阅读更多...
Docker核心技术：容器技术要解决哪些问题

Docker核心技术：容器技术要解决哪些问题

云原生学习路线导航页&#xff08;持续更新中&#xff09; 本文是 Docker核心技术 系列文章&#xff1a;容器技术要解决哪些问题&#xff0c;其他文章快捷链接如下&#xff1a; 应用架构演进容器技术要解决哪些问题&#xff08;本文&#xff09;Docker的基本使用Docker是如何实…
阅读更多...
Ubuntu20.04从零开搭PX4MavrosGazebo环境并测试

Ubuntu20.04从零开搭PX4MavrosGazebo环境并测试

仅仅是个人搭建记录 参考链接&#xff1a; https://zhuanlan.zhihu.com/p/686439920 仿真平台基础配置&#xff08;对应PX4 1.13版&#xff09; 语雀 mkdir -p ~/tzb/catkin_ws/src mkdir -p ~/tzb/catkin_ws/scripts cd catkin_ws && catkin init catkin build cd…
阅读更多...
RV1103使用rtsp和opencv推流视频到网页端

RV1103使用rtsp和opencv推流视频到网页端

参考&#xff1a; Luckfox-Pico/Luckfox-Pico-RV1103/Luckfox-Pico-pinout/CSI-Camera Luckfox-Pico/RKMPI-example Luckfox-Pico/RKMPI-example 下载源码 其中源码位置&#xff1a;https://github.com/luckfox-eng29/luckfox_pico_rtsp_opencv 使用git clone由于项目比较大&am…
阅读更多...
共享模型之无锁

共享模型之无锁

一、问题提出 1.1 需求描述 有如下的需求&#xff0c;需要保证 account.withdraw() 取款方法的线程安全&#xff0c;代码如下&#xff1a; interface Account {// 获取余额Integer getBalance();// 取款void withdraw(Integer amount);/*** 方法内会启动 1000 个线程&#xf…
阅读更多...
纯净IP代理网站解析与代理推荐

纯净IP代理网站解析与代理推荐

一、纯净IP代理网站解析 在浩瀚的代理服务市场中&#xff0c;纯净IP代理以其特有的优势脱颖而出。它们不仅提供高质量、无污染的IP资源&#xff0c;还注重服务的稳定性和安全性&#xff0c;确保用户在使用过程中能够享受到好的网络体验。纯净IP代理的优势在于其能够有效解决因…
阅读更多...
科技论文在线--适合练习期刊写作和快速发表科技成果论文投稿网站

科技论文在线--适合练习期刊写作和快速发表科技成果论文投稿网站

中国科技论文在线这个平台可以作为练手的一个渠道&#xff0c;至少可以锻炼一下中文写作&#xff0c;或者写一些科研方向的简单综述性文章。当然&#xff0c;如果你的老师期末要求也是交一份科技论文在线的刊载证明的话&#xff0c;这篇文章可以给你提供一些经验。 中国科技论…
阅读更多...
【引领未来智造新纪元：量化机器人的革命性应用】

【引领未来智造新纪元：量化机器人的革命性应用】

在日新月异的科技浪潮中&#xff0c;量化机器人正以其超凡的智慧与精准的操作&#xff0c;悄然改变着各行各业的生产面貌&#xff0c;成为推动产业升级、提升竞争力的关键力量。今天&#xff0c;让我们一同探索量化机器人在不同领域的广泛应用价值&#xff0c;见证它如何以科技…
阅读更多...
皇后游戏1

皇后游戏1

先把这个推导看完 现在我们来讲一下总结 首先&#xff0c;我们要观察到 c i c_i ci​递增&#xff0c;这样才能更简单&#xff0c;就不用像国王游戏那样在交换前后比较 i i i和 j j j的max了&#xff08;就是说&#xff0c;国王游戏需要比较 m a x ( c i , c j ) max(c_i,c_j)…
阅读更多...
获取本地时间(Linux下，C语言)

获取本地时间(Linux下，C语言)

一、函数 #include <time.h> time_t time(time_t *tloc);函数功能&#xff1a;获取本机时间&#xff08;以秒数存储&#xff0c;从1970年1月1日0:0:0开始到现在&#xff09;。返回值&#xff1a;获得的秒数&#xff0c;如果形参非空&#xff0c;返回值也可以通过传址调用…
阅读更多...
政安晨【零基础玩转各类开源AI项目】基于Ubuntu系统部署Hallo ：针对肖像图像动画的分层音频驱动视觉合成

政安晨【零基础玩转各类开源AI项目】基于Ubuntu系统部署Hallo ：针对肖像图像动画的分层音频驱动视觉合成

目录 背景介绍 训练与推理 训练 推理 开始部署 1. 把项目源码下载到本地 2. 创建 conda 环境 3. 使用 pip 安装软件包 4. 下载预训练模型 5. 准备推理数据 6. 运行推理 关于训练 为训练准备数据 训练 政安晨的个人主页&#xff1a;政安晨 欢迎 &#x1f44d;点赞…
阅读更多...
操作系统（3）——内存管理

操作系统（3）——内存管理

目录 小程一言专栏链接: [link](http://t.csdnimg.cn/6grrU)内存管理无存储器抽象存储器抽象实现以下几方面小结 虚拟内存实现以下方面总结 页面置换算法概述常见的页面置换算法先进先出&#xff08;FIFO&#xff09;算法最近最少使用&#xff08;LRU&#xff09;算法总结 小程…
阅读更多...
list（链表）容器的规则及list的高级排序案例

list（链表）容器的规则及list的高级排序案例

1.list的基本概念&#xff1a; 功能&#xff1a;将数据进行链式存储 list&#xff08;链表&#xff09;是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的 链表是由一系列节点组成&#xff0c;节点的组成包含存储数据元素的…
阅读更多...
【保卫花果山】游戏

【保卫花果山】游戏

游戏介绍 拯救花果山是一款玩家能够进行趣味闯关的休闲类游戏。拯救花果山中玩家需要保护花果山的猴子&#xff0c;利用各种道具来防御妖魔鬼怪的入侵&#xff0c;游戏中玩家需要面对的场景非常的多样&#xff0c;要找到各种应对敌人的方法。拯救花果山里玩家可以不断的进行闯…
阅读更多...
huawei USG6001v1学习----NAT和智能选路

huawei USG6001v1学习----NAT和智能选路

目录 1.NAT的分类 2.智能选路 1.就近选路 2.策略路由 3.智能选路 NAT:&#xff08;Network Address Translation&#xff0c;网络地址转换&#xff09; 指网络地址转换&#xff0c;1994年提出的。NAT是用于在本地网络中使用私有地址&#xff0c;在连接互联网时转而使用全局…
阅读更多...
在win10上通过WSL和docker安装Ubuntu子系统，并配置Ubuntu可成功使用宿主机GPU

在win10上通过WSL和docker安装Ubuntu子系统，并配置Ubuntu可成功使用宿主机GPU

本文主要记录win10系统上，通过WSL的Ubuntu系统以及Docker使用GPU的全部过程。 文章目录 1、 启用hyper-v2、 安装docker3、 安装WSL3.1 安装WSL23.1.1 检查是否安装了WSL23.1.1 安装和配置 WSL 23.2 安装Ubuntu 子系统3.3 检查并修改WSL版本4、docker配置ubuntu20.04 LTS5、下…
阅读更多...
最新文章

Copyright @ 2022~2023