链表基础知识详解（非常详细简单易懂）

概述：

      链表作为 C 语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。

文章目录

一、链表的概念

 链表的构成：

链表的操作:

 双向链表

链表与数组的对比

二、链表的创建

 三、链表的遍历

四、链表的释放

 五、链表节点的查找

六、链表节点的删除

七、链表中插入一个节点

八、链表排序

九、双向链表的创建和遍历

 十、双向链表插入节点

一、链表的概念

定义：

      链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

特点：

      链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成 （malloc），每个节点包括两个部分：

     一个是存储数据元素的数据域

     另一个是存储下一个节点地址的指针域

图1 单向链表

 链表的构成：

      链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

typedef struct student｛
 int num；
 char name[20]；
 struct student *next；
 }STU;

      链表节点分为两个域

      数据域：存放各种实际的数据，如：num、score等

      指针域：存放下一节点的首地址，如：next等.

图2 节点内嵌在一个数据结构中

链表的操作:

      链表最大的作用是通过节点把离散的数据链接在一起，组成一个表，这大概就是链表 的字面解释了吧。 链表常规的操作就是节点的插入和删除，为了顺利的插入，通常一条链 表我们会人为地规定一个根节点，这个根节点称为生产者。通常根节点还会有一个节点计 数器，用于统计整条链表的节点个数，具体见图3中的 root_node。

图3带根节点的链表

 双向链表

      双向链表与单向链表的区别就是节点中有两个节点指针，分别指向前后两个节点，其 它完全一样。有关双向链表的文字描述参考单向链表小节即可，有关双向链表的示意图具体见图4

图4双向链表

链表与数组的对比

      在很多公司的嵌入式面试中，通常会问到链表和数组的区别。在 C 语言中，链表与数 组确实很像，两者的示意图具体见图5，这里以双向链表为例。

图5 链表与数组的对比

      链表是通过节点把离散的数据链接成一个表，通过对节点的插入和删除操作从而实现 对数据的存取。而数组是通过开辟一段连续的内存来存储数据，这是数组和链表最大的区 别。数组的每个成员对应链表的节点，成员和节点的数据类型可以是标准的 C 类型或者是 用户自定义的结构体。数组有起始地址和结束地址，而链表是一个圈，没有头和尾之分， 但是为了方便节点的插入和删除操作会人为的规定一个根节点。

二、链表的创建

第一步：创建一个节点

 第二步：创建第二个节点，将其放在第一个节点的后面（第一的节点的指针域保存第二个节点的地址）

第三步：再次创建节点，找到原本链表中的最后一个节点，接着讲最后一个节点的指针域保存新节点的地址，以此内推。

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }
}

 三、链表的遍历

第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址

 第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移 

 

 第三步：以此类推，直到节点的指针域为NULL

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

四、链表的释放

重新定义一个指针q，保存p指向节点的地址，然后p后移保存下一个节点的地址，然后释放q对应的节点，以此类推，直到p为NULL为止

 //链表的释放
 void link_free(STU **p_head)
 {
   //定义一个指针变量保存头结点的地址
   STU *pb=*p_head;

  while(*p_head!=NULL)
  {
   //先保存p_head指向的结点的地址
   pb=*p_head;
   //p_head保存下一个结点地址
   *p_head=(*p_head)‐>next;
   //释放结点并防止野指针
   free(pb);
   pb = NULL;
  }
 }

 五、链表节点的查找

      先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下 一个结点，如果到达最后一个结点的时候都没有匹配的数据，说明要查找数据不存在


//链表的查找
//按照学号查找
STU * link_search_num(STU *head,int num)
{
    STU *p_mov;
    //定义的指针变量保存第一个结点的地址
    p_mov=head;
    //当没有到达最后一个结点的指针域时循环继续
    while(p_mov!=NULL)
    {
        //如果找到是当前结点的数据，则返回当前结点的地址
        if(p_mov->num == num)//找到了
        {
            return p_mov;
        }
        //如果没有找到，则继续对比下一个结点的指针域
        p_mov=p_mov->next;
    }

    //当循环结束的时候还没有找到，说明要查找的数据不存在，返回NULL进行标识
    return NULL;//没有找到
}

//按照姓名查找
STU * link_search_name(STU *head,char *name)
{
    STU *p_mov;
    p_mov=head;
    while(p_mov!=NULL)
    {
        if(strcmp(p_mov->name,name)==0)//找到了
        {
            return p_mov;
        }
        p_mov=p_mov->next;
    }
    return NULL;//没有找到
}

六、链表节点的删除

      如果链表为空，不需要删除 如果删除的是第一个结点，则需要将保存链表首地址的指针保存第一个结点的下一个结点的 地址 如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结 点的后一个结点的地址即可

//链表结点的删除
void link_delete_num(STU **p_head,int num)
{
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head == NULL)//链表为空，不用删
    {
        printf("链表为空，没有您要删的节点");\
        return ;
    }
    while(pb->num != num && pb->next !=NULL)//循环找，要删除的节点
    {
        pf=pb;
        pb=pb->next;
    }
    if(pb->num == num)//找到了一个节点的num和num相同
    {
        if(pb == *p_head)//要删除的节点是头节点
        {
            //让保存头结点的指针保存后一个结点的地址
            *p_head = pb->next;
        }
        else
        {
            //前一个结点的指针域保存要删除的后一个结点的地址
            pf->next = pb->next;
        }

        //释放空间
        free(pb);
        pb = NULL;
    }
    else//没有找到
    {
        printf("没有您要删除的节点\n");
    }
}

七、链表中插入一个节点

链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置

 情况（按照从小到大）：

      如果链表没有结点，则新插入的就是第一个结点。

      如果新插入的结点的数值最小，则作为头结点。

      如果新插入的结点的数值在中间位置，则找到前一个，然后插入到他们中间。

      如果新插入的结点的数值最大，则插入到最后。

//链表的插入：按照学号的顺序插入
void link_insert_num(STU **p_head,STU *p_new)
{
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head ==NULL)// 链表为空链表
    {
        *p_head = p_new;
        p_new->next=NULL;
        return ;
    }
    while((p_new->num >= pb->num)  && (pb->next !=NULL) )
    {
        pf=pb;
        pb=pb->next;
    }

    if(p_new->num < pb->num)//找到一个节点的num比新来的节点num大，插在pb的前面
    {
        if(pb== *p_head)//找到的节点是头节点，插在最前面
        {
            p_new->next= *p_head;
            *p_head =p_new;
        }
        else
        {
            pf->next=p_new;
            p_new->next = pb;
        }
    }
    else//没有找到pb的num比p_new->num大的节点，插在最后
    {
        pb->next =p_new;
        p_new->next =NULL;
    }
}

八、链表排序

      如果链表为空，不需要排序。

      如果链表只有一个结点，不需要排序。

      先将第一个结点与后面所有的结点依次对比数据域，只要有比第一个结点数据域小的，则交 换位置。

       交换之后，拿新的第一个结点的数据域与下一个结点再次对比，如果比他小，再次交换，依 次类推。

      第一个结点确定完毕之后，接下来再将第二个结点与后面所有的结点对比，直到最后一个结 点也对比完毕为止。

//链表的排序
void link_order(STU *head)
{
    STU *pb,*pf,temp;
    pf=head;

    if(head==NULL)
    {
        printf("链表为空,不用排序\n");
        return ;
    }

    if(head->next ==NULL)
    {
        printf("只有一个节点，不用排序\n");
        return ;
    }

    while(pf->next !=NULL)//以pf指向的节点为基准节点，
    {
        pb=pf->next;//pb从基准元素的下个元素开始
        while(pb!=NULL)
        {
            if(pf->num > pb->num)
            {
                temp=*pb;
                *pb=*pf;
                *pf=temp;

                temp.next=pb->next;
                pb->next=pf->next;
                pf->next=temp.next;
            }
            pb=pb->next;
        }
        pf=pf->next;
    }
}

九、双向链表的创建和遍历

第一步：创建一个节点作为头节点，将两个指针域都保存NULL

第二步：先找到链表中的最后一个节点，然后让最后一个节点的指针域保存新插入节点的地址，新插入节点的两个指针域，一个保存上一个节点的地址，一个保存NULL

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

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名

    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov=*p_head;
    if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->front = NULL;
        p_new->next = NULL;
    }
    else	//第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;
    }
}


void double_link_print(STU *head)
{
    STU *pb;
    pb=head;
    while(pb->next!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);

    printf("***********************\n");

    while(pb!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

int main()
{
    STU *head=NULL,*p_new=NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n");	//给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_creat_head(&head,p_new);	//将新节点加入链表
    }

    double_link_print(head);
}

 十、双向链表插入节点

按照顺序插入结点

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

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名

    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov=*p_head;
    if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->front = NULL;
        p_new->next = NULL;
    }
    else	//第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;
    }
}


void double_link_print(STU *head)
{
    STU *pb;
    pb=head;
    while(pb->next!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);

    printf("***********************\n");

    while(pb!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

//双向链表的删除
void double_link_delete_num(STU **p_head,int num)
{
    STU *pb,*pf;
    pb=*p_head;
    if(*p_head==NULL)//链表为空，不需要删除
    {
        printf("链表为空，没有您要删除的节点\n");
        return ;
    }
    while((pb->num != num) && (pb->next != NULL) )
    {
        pb=pb->next;
    }
    if(pb->num == num)//找到了一个节点的num和num相同，删除pb指向的节点
    {
        if(pb == *p_head)//找到的节点是头节点
        {
            if((*p_head)->next==NULL)//只有一个节点的情况
            {
                *p_head=pb->next;
            }
            else//有多个节点的情况
            {
                *p_head = pb->next;//main函数中的head指向下个节点
                (*p_head)->front=NULL;
            }
        }
        else//要删的节点是其他节点
        {
            if(pb->next!=NULL)//删除中间节点
            {
                pf=pb->front;//让pf指向找到的节点的前一个节点
                pf->next=pb->next; //前一个结点的next保存后一个结点的地址
                (pb->next)->front=pf; //后一个结点的front保存前一个结点的地址
            }
            else//删除尾节点
            {
                pf=pb->front;
                pf->next=NULL;
            }
        }

        free(pb);//释放找到的节点

    }
    else//没找到
    {
        printf("没有您要删除的节点\n");
    }
}

int main()
{
    STU *head=NULL,*p_new=NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n");	//给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_creat_head(&head,p_new);	//将新节点加入链表
    }

    double_link_print(head);

    printf("请输入您要删除的节点的num\n");
    scanf("%d",&num);
    double_link_delete_num(&head,num);
    double_link_print(head);

}

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

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

相关文章

[Linux]如何理解kernel、shell、bash

[Linux]如何理解kernel、shell、bash

文章目录 概念总览kernelshell&bash 概念总览 内核(kernel) &#xff0c;外壳(shell) &#xff0c;bash kernel kernel是指操作系统中的核心部分&#xff0c;用户一般是不能直接使用kernel的。它主要负责管理硬件资源和提供系统服务&#xff0c;如内存管理、进程管理、文件…
阅读更多...
国内chatgpt写作软件,chatgpt国内使用

国内chatgpt写作软件,chatgpt国内使用

随着人工智能技术的不断发展&#xff0c;国内涌现出了一些基于ChatGPT模型的写作软件&#xff0c;这些软件不仅能够实现智能化的文章写作&#xff0c;还支持批量生成各种类型的文章。本文将深入探讨国内ChatGPT写作软件&#xff0c;以及它们在批量文章创作方面的应用与优势。 C…
阅读更多...
如何使用Docker搭建StackEdit编辑器并结合内网穿透实现远程办公

如何使用Docker搭建StackEdit编辑器并结合内网穿透实现远程办公

文章目录 前言1. ubuntu安装VNC2. 设置vnc开机启动3. windows 安装VNC viewer连接工具4. 内网穿透4.1 安装cpolar【支持使用一键脚本命令安装】4.2 创建隧道映射4.3 测试公网远程访问 5. 配置固定TCP地址5.1 保留一个固定的公网TCP端口地址5.2 配置固定公网TCP端口地址5.3 测试…
阅读更多...
K线实战分析系列之十七：三法形态——接连犹豫后再次坚定

K线实战分析系列之十七：三法形态——接连犹豫后再次坚定

K线实战分析系列之十七&#xff1a;三法形态——接连犹豫后再次坚定 一、三法形态二、总结三法形态 一、三法形态 前后两根长K线中间夹了三根短小的K线 二、总结三法形态 中间的几根小阴线数量限制没有那么严苛中间小K线的颜色不一定是依次下降的小阴线或小阳线&#xff0c;也…
阅读更多...
NOC2023软件创意编程（学而思赛道）python小高组复赛真题

NOC2023软件创意编程（学而思赛道）python小高组复赛真题

目录 下载原文档打印做题： 软件创意编程 一、参赛范围 1.参赛组别：小学低年级组（1-3 年级）、小学高年级组（4-6 年级）、初中组。 2.参赛人数：1 人。 3.指导教师：1 人（可空缺）。 4.每人限参加 1 个赛项。 组别确定：以地方教育行政主管部门（教委、教育厅、教育局） 认…
阅读更多...
【C++】vector的使用和模拟实现（超级详解！！！！）

【C++】vector的使用和模拟实现（超级详解！！！！）

文章目录 前言1.vector的介绍及使用1.1 vector的介绍1.2 vector的使用1.2.1 vector的定义1.2.2 vector iterator 的使用1.2.3 vector 空间增长问题1.2.3 vector 增删查改1.2.4 vector 迭代器失效问题。&#xff08;重点!!!!!!&#xff09;1.2.5 vector 在OJ中有关的练习题 2.ve…
阅读更多...
朱维群将出席用碳不排碳碳中和顶层科技路线设计开发

朱维群将出席用碳不排碳碳中和顶层科技路线设计开发

演讲嘉宾&#xff1a;朱维群 演讲题目&#xff1a;“用碳不排碳”碳中和顶层科技路线设计开发 简介 姓名&#xff1a;朱维群 性别&#xff1a;男 出生日期&#xff1a;1961-09-09 职称&#xff1a;教授 1998年毕业于大连理工大学精细化工国家重点实验室精细化工专业&…
阅读更多...
AWTK 开源串口屏开发(11) - 天气预报

AWTK 开源串口屏开发(11) - 天气预报

# AWTK 开源串口屏开发 - 天气预报 天气预报是一个很常用的功能&#xff0c;在很多设备上都有这个功能。实现天气预报的功能&#xff0c;不能说很难但是也绝不简单&#xff0c;首先需要从网上获取数据&#xff0c;再解析数据&#xff0c;最后更新到界面上。 在 AWTK 串口屏中…
阅读更多...
探索那些能唤起情感共鸣的壁纸

探索那些能唤起情感共鸣的壁纸

1、方小童在线工具集 网址&#xff1a; 方小童 该网站是一款在线工具集合的网站&#xff0c;目前包含PDF文件在线转换、随机生成美女图片、精美壁纸、电子书搜索等功能&#xff0c;喜欢的可以赶紧去试试&#xff01;
阅读更多...
基于Beego 1.12.3的简单website实现

基于Beego 1.12.3的简单website实现

参考 用Beego开发web应用 https://www.cnblogs.com/zhangweizhong/p/10919672.htmlBeego官网 Homepage - beego: simple & powerful Go app frameworkbuild-web-application-with-golang https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/pr…
阅读更多...
概率基础——多元正态分布

概率基础——多元正态分布

概率基础——多元正态分布 介绍 多元正态分布是统计学中一种重要的多维概率分布&#xff0c;描述了多个随机变量的联合分布。在多元正态分布中&#xff0c;每个随机变量都服从正态分布&#xff0c;且不同随机变量之间可能存在相关性。本文将以二元标准正态分布为例&#xff0…
阅读更多...
PVLAN组网实验

PVLAN组网实验

一&#xff0c;PVLAN类型 主VLAN 主VLAN可以由多个辅助私用VLAN组成&#xff0c;而这些辅VLAN与主VLAN属于同一子网。 辅助VLAN ① 团体VLAN&#xff1a;如果某个端口属于团体VLAN&#xff0c;那么它就不仅能够与相同团体VLAN中的其他端口进行通信&#xff0c;而且还能够与…
阅读更多...
【5G 接口协议】GTP-U协议介绍

【5G 接口协议】GTP-U协议介绍

博主未授权任何人或组织机构转载博主任何原创文章&#xff0c;感谢各位对原创的支持&#xff01; 博主链接 本人就职于国际知名终端厂商&#xff0c;负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作&#xff0c;目前牵头6G算力网络技术标准研究。 博客…
阅读更多...
HTML~

HTML~

HTML HTML是一门语言&#xff0c;所有的网页都是用HTML这门语言编写出来的HTML(HyperText Markup Language):超文本标记语言 超文本:超越了文本的限制&#xff0c;比普通文本更强大。除了文字信息&#xff0c;还可以定义图片、音频、视频等内容 标记语言:由标签构成的语言 …
阅读更多...
SpringBoot源码解读与原理分析(三十八)SpringBoot整合WebFlux(一)WebFlux的自动装配

SpringBoot源码解读与原理分析(三十八)SpringBoot整合WebFlux(一)WebFlux的自动装配

文章目录 前言第13章 SpringBoot整合WebFlux13.1 响应式编程与Reactor13.1.1 命令式与响应式13.1.2 异步非阻塞13.1.3 观察者模式13.1.4 响应性13.1.5 响应式流13.1.6 背压13.1.7 Reactor13.1.7.1 Publisher13.1.7.2 Subscriber13.1.7.3 Subscription13.1.7.4 Processor13.1.7.…
阅读更多...
Python爬虫——解析常用三大方式之Xpath

Python爬虫——解析常用三大方式之Xpath

目录 Xpath 安装xpath 安装lxml库 导入lxml库 解析本地文件 etree.parse&#xff08;&#xff09; 解析服务器响应文件 etree.HTML() xpath基本语法 小案例&#xff1a;获取百度首页的百度一下 大案例&#xff1a;爬取站长素材图片 总结 Xpath 安装xpath 首先要学会安…
阅读更多...
大模型（LLM）的量化技术Quantization原理学习

大模型（LLM）的量化技术Quantization原理学习

在自然语言处理领域&#xff0c;大型语言模型&#xff08;LLM&#xff09;在自然语言处理领域的应用越来越广泛。然而&#xff0c;随着模型规模的增大&#xff0c;计算和存储资源的需求也急剧增加。为了降低计算和存储开销&#xff0c;同时保持模型的性能&#xff0c;LLM大模型…
阅读更多...
【排序算法】冒泡排序

【排序算法】冒泡排序

目录 概述 冒泡排序原理 冒泡排序的Java实现 总结 概述 冒泡排序是一种简单但低效的排序算法。它重复地走访要排序的元素列&#xff0c;一次比较两个元素&#xff0c;如果它们的顺序错误就交换它们&#xff0c;直到没有元素需要交换。这个过程类似于气泡在水中上浮的过程&am…
阅读更多...
开源模型Mistral 7B+Amazon SageMaker部署指南

开源模型Mistral 7B+Amazon SageMaker部署指南

一、Mistral 7B简述 Mistral AI 是一家总部位于法国的 AI 公司&#xff0c;其使命是将公开可用的模型提升至最先进的性能水平。他们专注于构建快速而安全的大型语言模型&#xff08;LLM&#xff09;&#xff0c;此类模型可用于从聊天机器人到代码生成等各种任务。不久前其发布…
阅读更多...
leetcode hot100 每日温度

leetcode hot100 每日温度

在本题中&#xff0c;我们是通过单调栈来解决的&#xff0c;因为我们采用了栈的数据结构&#xff0c;并且&#xff0c;栈内存储的元素是单调的。 本题我们考虑&#xff0c;将气温数组元素的下标存入栈中&#xff0c;首先初始化要把0放入&#xff0c;0是下标的意思。然后我们拿…
阅读更多...
最新文章

Copyright @ 2022~2023