linux 学习day15

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量733 收藏 13
点赞数 7
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuziNO_1/article/details/140558811
版权

链表的引入

1.1 总结顺序表的优缺点

1> 优点：能够直接通过下标进行定位元素，访问效率高，对元素进行查找和修改比较快

2> 不足：插入和删除元素需要移动大量的元素，效率较低

3> 缺点：存储数据元素有上限，当达到MAX后，就不能再添加元素了

 1.2 链表的概念

1> 链式存储的线性表叫做链表

1、链式存储：表示数据元素的存储地址不一定连续

2、线性表：数据元素之间存在一对一的关系

 2> 链表的原理图如下

 3> 链表的基础概念

1、节点：节点是链表的基本单位，由数据域和指针域组成

2、数据域：存放数据元素的部分

3、指针域：存放下一个节点地址的部分

4、前驱节点：当前节点的上一个节点

5、后继节点：当前节点的下一个节点

6、头节点：虚设的一个节点，数据域不存放数据元素，可以存放链表的长度

7、头指针：指向第一个节点的指针称为头指针

8、第一个节点：实际存储数据元素的链表上的第一个节点 注意：头节点的指针域其实就是头指针，也可以单独定义一个指针，指向第一个节点

 4> 链表的分类

1、单向链表：只能从头节点或第一个节点出发，单向访问其后继节点的链表称为单向链表

2、双向链表：从头部出发，既可以访问前驱节点，也可以访问后继节点
3、循环链表：首尾相接的链表称为循环链表

 单向链表

只能从头节点或第一个节点出发，单向访问其后继节点的链表称为单向链表

2.1 节点结构体类型

1> 头节点和普通节点数据域可以合到一起，使用一格共用体表示

2> 指针域都是指向普通节点的地址

//定义数据类型

typedef int datatype;

//定义结点类型

typedef struct Node

{

        union

        {

                int len; //头结点数据域

                datatype data; //普通结点数据域

        };

};struct Node *next; //指针域

 2.2 创建链表

1> 在堆区申请一格头节点的空间，就创建了一个链表

2> 需要对头节点的数据域初始化链表长度，指针域初始化NULL

//创建链表
NodePtr list_create()
{
    //只需要在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }

    //程序执行至此，说明头结点创建结束
    L->len = 0;    //表示链表长度为0
    L->next = NULL;      ///防止野指针

    printf("链表创建成功\n");
    return L;
}

2.3 申请节点封装数据

 1> 需要将要封装的数据当做函数的参数进行传递

2> 同样在堆区申请节点，就传入的数据放入数据域

//申请结点封装数据函数
NodePtr apply_node(datatype e)
{
    //在堆区申请一个结点的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("结点申请失败\n");
        return NULL;
    }

    //给结点内容赋值
    p->data = e;          //数据域赋值
    p->next = NULL;        //指针域

    return p;
}

 2.4 链表判空

1> 只需要判断头节点的指针域中是否为空即可

//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}

2.5 头插

1> 表示将新插入的节点放入第一个节点中

2> 插入数据时，不能先将前面节点与后面节点先断开。一定要从新节点出发，指向后面的节点，然后将前驱节点指向字节

//头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1;
    }

    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    p->next = L->next;
    L->next = p;
    
    
    //表的变化
    L->len ++;
    printf("头插成功\n");
    return 0;
}

2.6 链表遍历

需要使用一个遍历指针，将每一个节点进行遍历一遍，如果该指针指向的节点不为空，就访问其数据域，向后偏移

//链表遍历函数
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }
    
    printf("链表中的元素分别是：");
    //遍历逻辑
    NodePtr q = L->next;   //定义遍历指针从第一个结点出发
    while(q != NULL)
    {
        //输出数据域
        printf("%d\t", q->data);

        q = q->next;    //指针向后偏移一个
    }
}

 2.7 通过位置查找节点

1> 参数：链表、位置

2> 返回值：对应节点的地址

//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //查找逻辑
    //定义遍历指针从头结点出发
    NodePtr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    return q;     //将找到的结点地址返回
}

 2.8 任意位置插入元素

1> 参数：链表、位置、要插入的元素

2> 返回值：int

3> 注意：必须找到要插入位置的节点的前驱节点，将前驱节点当作头节点，进行头插操作

//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }
    
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
    
    //调用函数查找前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //插入逻辑
    p->next = q->next;
    q->next = p;
    
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

2.9 链表头删

1> 参数：链表

2> 返回值：int

3> 注意：需要将要删除的节点先标记一下，头节点的指针，指向第二个节点后，将标记的节点释放

//链表头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    
    //删除三部曲
    NodePtr p = L->next;    //标记
    L->next = p->next;  //L->next->next  孤立
    free(p);            //释放
    p = NULL;

    //表长变化
    L->len--;

    printf("头删成功\n");
    return 0;
}

2.10 任意位置删除函数

1> 参数：链表、要删除的位置

2> 返回值:int

3> 注意：需要找到要删除的节点的前驱节点，将其当作头节点，进行头删逻辑

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //删除逻辑
    NodePtr p = q->next;           //标记
    q->next = q->next->next;   //p->next 孤立
    free(p);                   //释放
    p = NULL;

    
    //表的变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

2.11 按值查找返回位置

1> 参数：链表、要查找的值

2> 返回值：元素在链表中的位置

//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }
    
    //查找逻辑
    //定义遍历指针从第一个结点出发
    NodePtr q = L->next;
    for(int index=1; index<=L->len; index++)
    {
        //判断当前结点的值是否为要找的数据
        if(q->data == e)
        {
            return index;
        }

        q = q->next;     //继续向后遍历
    }

    //程序执行至此，表示没找到
    printf("没找到\n");
    return -1;
}

 2.12 按位置修改

1> 参数：链表、要修改的元素位置、要被更新的值

2> 返回值：int

3> 注意：先通过位置，找到对应的元素，更改该元素中的内容即可

//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按位置查找逻辑
    NodePtr p = list_search_pos(L, pos);
    
    //修改逻辑
    p->data = e;

    printf("修改成功\n");
    return 0;
}

2.13 按值进行修改函数

1> 参数：链表、旧值、新值

2> 返回值：int

3> 思路：先通过旧值找到位置，通过位置进行修改

//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按值查找位置
    int res = list_search_value(L, old_e);
    if(res == -1)
    {
        printf("没有要修改的值\n");
        return -1;
    }
    
    //按位置修改
    list_update_pos(L, res, new_e);
    
    printf("修改成功\n");
    return 0;
}

2.14 链表的反转

1> 参数：链表

2> 返回值：int

3> 注意：在该操作中，没有节点被删除，也没有节点被释放

//将链表进行翻转
void list_reverse(NodePtr L)
{
    //判断逻辑
    if(NULL==L || L->len<=1)
    {
        printf("翻转失败\n");
        return ;
    }
    
    //翻转逻辑
    NodePtr H = L->next;   //将链表元素进行托付

    L->next = NULL;        //自己白手起家

    NodePtr p = NULL;         //结点的搬运工

    while(H != NULL)
    {
        p = H;      //搬运第一个结点
        H = H->next;     //头指针后移

        //将p以头插的方式放入L中
        p->next = L->next;
        L->next = p;
    }

    printf("翻转成功\n");
    
}

2.15 链表的释放

1> 参数：链表

2> 返回值：无

3> 注意：需要先将所有的节点内存全部释放后，再将头节点释放

//释放链表
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL == L)
    {
        return;
    }

    //将所有结点进行释放
    while(!list_empty(L))
    {
        //头删
        list_delete_head(L);
    }

    //释放头结点
    free(L);
    L = NULL;

    printf("释放成功\n");
}

2.16 代码总结

linklist.h
#ifndef LINKLIST_H
#define LINKLIST_H
#include<myhead.h>

//定义数据类型
typedef int datatype;

//定义结点类型
typedef struct Node
{
    union
    {
        int len;    //头结点数据域
        datatype data;  //普通结点数据域
    };

    struct Node *next;   //指针域
}Node, *NodePtr;

//创建链表
NodePtr list_create();

//申请结点封装数据函数
NodePtr apply_node(datatype e);

//链表判空
int list_empty(NodePtr L);

//头插
int list_insert_head(NodePtr L, datatype e);

//链表遍历函数
int list_show(NodePtr L);

//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos);

//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e);

//链表头删
int list_delete_head(NodePtr L);

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos);

//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e);

//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e);

//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e);

//将链表进行翻转
void list_reverse(NodePtr L);

//释放链表
void list_destroy(NodePtr L);





#endif
linklist.c
#include"linklist.h"

//创建链表
NodePtr list_create()
{
    //只需要在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }

    //程序执行至此，说明头结点创建结束
    L->len = 0;    //表示链表长度为0
    L->next = NULL;      ///防止野指针

    printf("链表创建成功\n");
    return L;
}



//申请结点封装数据函数
NodePtr apply_node(datatype e)
{
    //在堆区申请一个结点的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("结点申请失败\n");
        return NULL;
    }

    //给结点内容赋值
    p->data = e;          //数据域赋值
    p->next = NULL;        //指针域

    return p;
}


//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}

//头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1;
    }

    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    p->next = L->next;
    L->next = p;
    
    
    //表的变化
    L->len ++;
    printf("头插成功\n");
    return 0;
}


//链表遍历函数
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }
    
    printf("链表中的元素分别是：");
    //遍历逻辑
    NodePtr q = L->next;   //定义遍历指针从第一个结点出发
    while(q != NULL)
    {
        //输出数据域
        printf("%d\t", q->data);

        q = q->next;    //指针向后偏移一个
    }
    printf("\n");
}

//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //查找逻辑
    //定义遍历指针从头结点出发
    NodePtr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    return q;     //将找到的结点地址返回
}



//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }
    
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
    
    //调用函数查找前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //插入逻辑
    p->next = q->next;
    q->next = p;
    
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

//链表头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    
    //删除三部曲
    NodePtr p = L->next;    //标记
    L->next = p->next;  //L->next->next  孤立
    free(p);            //释放
    p = NULL;

    //表长变化
    L->len--;

    printf("头删成功\n");
    return 0;
}

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //删除逻辑
    NodePtr p = q->next;           //标记
    q->next = q->next->next;   //p->next 孤立
    free(p);                   //释放
    p = NULL;

    
    //表的变化
    L->len--;
    printf("删除成功\n");
    return 0;
}


//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }
    
    //查找逻辑
    //定义遍历指针从第一个结点出发
    NodePtr q = L->next;
    for(int index=1; index<=L->len; index++)
    {
        //判断当前结点的值是否为要找的数据
        if(q->data == e)
        {
            return index;
        }

        q = q->next;     //继续向后遍历
    }

    //程序执行至此，表示没找到
    printf("没找到\n");
    return -1;
}


//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按位置查找逻辑
    NodePtr p = list_search_pos(L, pos);
    
    //修改逻辑
    p->data = e;

    printf("修改成功\n");
    return 0;
}



//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按值查找位置
    int res = list_search_value(L, old_e);
    if(res == -1)
    {
        printf("没有要修改的值\n");
        return -1;
    }
    
    //按位置修改
    list_update_pos(L, res, new_e);
    
    printf("修改成功\n");
    return 0;
}



//将链表进行翻转
void list_reverse(NodePtr L)
{
    //判断逻辑
    if(NULL==L || L->len<=1)
    {
        printf("翻转失败\n");
        return ;
    }
    
    //翻转逻辑
    NodePtr H = L->next;   //将链表元素进行托付

    L->next = NULL;        //自己白手起家

    NodePtr p = NULL;         //结点的搬运工

    while(H != NULL)
    {
        p = H;      //搬运第一个结点
        H = H->next;     //头指针后移

        //将p以头插的方式放入L中
        p->next = L->next;
        L->next = p;
    }

    printf("翻转成功\n");
    
}

//释放链表
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL == L)
    {
        return;
    }

    //将所有结点进行释放
    while(!list_empty(L))
    {
        //头删
        list_delete_head(L);
    }

    //释放头结点
    free(L);
    L = NULL;

    printf("释放成功\n");
}
main.c
#include"linklist.h"

int main(int argc, const char *argv[])
{
    
    //调用函数创建一个链表
    NodePtr L = list_create();
    if(NULL == L)
    {
        return -1;
    }

    //调用头插函数
    list_insert_head(L, 520);
    list_insert_head(L, 1314);
    list_insert_head(L, 666);
    list_insert_head(L, 999);
    
    //调用遍历函数
    list_show(L);

    //调用任意位置插入函数
    list_insert_pos(L, 1, 100);
    list_insert_pos(L, 3, 100);
    list_insert_pos(L, L->len+1, 100);
    list_show(L);

    //调用头删函数
    list_delete_head(L);
    list_delete_head(L);
    list_show(L);

    //调用删除函数
    list_delete_pos(L, 1);
    list_delete_pos(L, 2);
    list_delete_pos(L, L->len);
    list_show(L);

    //调用按值查找位置
    int res = list_search_value(L, 666);
    if(res != -1)
    {
        printf("您要找的数据在链表的第%d个位置\n", res);
    }

    //调用按位置进行修改函数
    list_update_pos(L, 1, 12345);
    list_show(L);

    //调用按值修改函数
    list_update_value(L, 12345, 6789);
    list_show(L);

    //调用翻转函数
    list_reverse(L);
    list_show(L);

    //调用释放函数
    list_destroy(L);
    L = NULL;


    return 0;
}

wuziNO_1
关注
Linux学习笔记day01
Wynb1020的博客
01-07 1353
Linux文件与目录结构 Linux一切皆文件 目录结构 目录名 释义 /bin (/usr/bin、/usr\local\bin) 是Binary的缩写, 这个目录存放着最经常使用的命令 /home 存放普通用户的主目录，在Linux中每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。 /root 该目录为系统管理员，也称作超级权限者的用户主目录。 /etc 所有的系统管理所需要的配置文件和子目录 /usr 这是一个非常重要的目录，用户的很多应用程序和文件都放
Linux学习手册大全
热门推荐
小龙博客
07-17 3万+
、 Linux大全1、虚拟机安装2、虚拟机网络连接方式3、安装vmtools4、虚拟机目录4.1、目录含义4.2、Linux颜色含义5、远程登录软件6、编辑命令7、用户管理8、CentOS7找回root密码9、文件目录指令pwd指令ls指令cd指令mkdir指令rmdir指令touch指令cp指令rm指令mv指令cat指令more指令less指令echo指令head指令tail指令指令>和指令>>ln指令history指令10、日期指令11、查找指令1、find指令2、locate指令3、
Linux学习-day2
qq_41784433的博客
04-08 1296
文章目录1、远程登录和文件传输2、vi和vim编辑器2.1、三种模式2.2、快捷键3、Linux开机、重启、用户登录、注销3.1、关机、重启3.2、用户登陆、注销 1、远程登录和文件传输 查看虚拟机的IP：ifconfig，但是首先要保证虚拟机是联网了的。 2、vi和vim编辑器 2.1、三种模式 2.2、快捷键 复制某一行直接找到对应那一行输入yy p即可，复制多行先找到起始行，然后输入(第几行的数字) yy，然后光标下移到想复制的行位置，再输入一个p即可。 删除同理。 查找是先进入了之后，
Linux操作系统学习：day01
qq_45545681的博客
06-10 1265
POSIX 标准是对 UNIX 操作系统的经验和实践的总结，每启动一个可执行程序都会得到一个进程，进程的运行需要CPU的加持，而CPU的资源有限，如果要同时执行多个可执行程序（即，同时处理多个进程），需要分时复用CPU的时间片，时间的长短由内核决定。进程之间需要进行数据的交流才能完成控制、协同工作等功能，Linux 的进程间通信是从 UNIX 系统继承过来的。Linux 是 UNIX 操作系统的一个克隆系统, 但是Linux是开源的。进程调度指的是系统对进程的多种状态之间转换的策略。的版本，进行安装使用。
Linux学习-day1
qq_41784433的博客
04-04 1318
文章目录 学习地址：韩顺平Linux 学习目标：工作中可以做到灵活使用。
Linux学习-day3
qq_41784433的博客
04-09 1300
文章目录1、Linux组1.1、基本介绍1.2、所有者1.3、组的创建、文件/目录所在组1.3.1、组的创建1.3.2、文件/目录所在组1.4、其他组2、权限2.1、基本介绍 1、Linux组 1.1、基本介绍 一般谁创建了这个文件，这个文件的所有者就是那个人，当然也是可以更改的。 文件属于哪个组，这个组里所有用户对文件有一定的权限。 其他组：比如a.txt属于组1的，组2、组3就属于其他组，其他组里所有用户对文件有一定的权限。 1.2、所有者 1.3、组的创建、文件/目录所在组 1.3.1、组的创
Linux学习day01_Linux安装
谢知行
05-20 212
Linux学习day01_Linux安装
Linux 指令学习之crontab
zhouzhiwengang的专栏
12-17 3493
crontab可以在指定的时间执行一个shell脚本以及执行一系列Linux命令.
【Linux学习day1】VirtualBox安装+创建虚拟机
qq_41870483的博客
08-22 1219
virtualBox安装教程
linux学习-day6
qq_41784433的博客
04-17 967
文章目录1、Ubuntu安装 1、Ubuntu安装
Linux课程Day2
02-17
在“Linux课程Day2”中，我们将会深入探讨Linux操作系统的核心概念和常用命令，这是学习Linux系统管理和自动化工作流程的基础。Linux是一种免费且开源的操作系统，它的灵活性和稳定性使其成为服务器、开发环境以及...
Linux入门 day1
01-20
太原理工大学机器人团队20天学习打卡 DAY 1 笔者不喜欢啰嗦，力求看得少学得多并且好理解，那么还是直入主题，开门见山吧！ 本次我们先学习Linux的常用命令。 有人肯定会想为什么不先学习Linux操作系统？ 笔者认为...
linux学习资料（全）
02-22
本学习资料包含"Unix-day01"和"Unix-day02"两个部分，旨在全面覆盖Linux的基础知识和进阶技能，帮助学习者从零开始掌握Linux运维技术。 在"Unix-day02.pdf"中，可能涵盖以下知识点： 1. **Linux历史与哲学**：了解...
Linux-Day01.pdf
08-14
学习 Linux 操作系统的重要性体现在以下几个方面： 1. 企业用人要求：许多招聘网站上的岗位要求都提到了 Linux 操作系统的经验。作为 JavaEE 开发工程师，企业需要我们具备 Linux 操作系统的相关知识，因为 Linux ...
Linux学习DAY6-认识与学习BASH
2302_81664454的博客
06-19 1717
硬件：整个系统的实体工作者，包含了硬盘、cpu等核心：控制硬件工作shell：使用者界面。
计算左边（比自己小的元素）的最长距离
wniuniu_的博客
09-14 99
前言：一般做的题目都是使用单调栈来求出距离这个点最近的那个比这个数大或小的元素，但是如果是需要找到最远的那个元素呢？我们可以用到类似逆序对的思路，我们先进行排序从小到大，接着我们先处理左边，每次维护一个最小的下标。
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1131
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 602
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 395
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
"苏国勇 C语言学习笔记Day11：编程环境介绍与Linux常用命令
通过学习常用的Linux命令，他加深了对Linux操作系统的理解，提高了在Linux环境下的操作技能。 综上所述，苏国勇在学习C语言的过程中表现出了极大的热情和努力，通过认真听课、下课梳理、早睡早起等良好的学习习惯，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值