学习记录——day15 数据结构 链表

news2024/9/21 14:32:30

链表的引入

顺序表的优缺点

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

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

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

链表的概率概念

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

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

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

2、链表的原理

3、链表的基本单位

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

        2）数据域:存放数据元素的部分

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

        4）前驱节点:当前节点的上一个节点

        5）后继节点:当前节点的下一个节点

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

        7）头指针:指向第一个节点的指针称为头指针

        8）第一个节点:实际存储数据元素的链表上的第一个节点

        注意：头节点的指针域其实就是头指针，也可以单独定义一个指针，指向第一个节点

4、链表的分类

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

        2）双向链表：双向链表:从头部出发，既可以访问前驱节点，也可以访问后继节点

        3）循环链表:首尾相接的链表称为循环链表

单向链表

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

1、节点结构体类型

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

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

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

//定义节点类型
typedef struct Node
{
    union 
    {
        int len;
        datatype data;
    };
    
    struct Node *next; 
    
};

2、创建列表

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

        2）

//创建列表
NodePrt list_create()
{
    //在堆区申请一个头节点
    NodePrt L = (NodePrt)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");  
        return NULL;
    }

    L->len = 0;
    L->next = NULL;

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

3、申请节点封装数据

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

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

//申请节点 封装数据
NodePrt apply_node(datatype e)
{
    //申请节点大小
    NodePrt p = (NodePrt)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("节点创建失败\n");  
        return NULL;
    }

    //给节点赋值 
    p->data = e;
    p->next = NULL;

    printf("节点创建成功\n");
    return p;
}

4、链表判空

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

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

5、头插

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

        2）插入数据时，不能先将前面节点与后面节点先断开。

        3）一定要从新节点出发，指向后面的节点，然后将前驱节点指向字节

//头插
int list_inser_head(NodePrt L,datatype e)
{
    if (NULL == L)
    {
        printf("链表不合法\n");
        return -1;
    }
    NodePrt p = apply_node(e);

    if (NULL == p)
    {
        return -1;
    }
    p->next = L->next;
    L->next = p;

    L->len++;
    
    printf("头插成功\n");
    
    return 0;
}

6、链表遍历

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

      

//链表遍历
int list_show(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }

    NodePrt q = L->next;//定义遍历指针从第一个节点出发
    while(q)
    {
        //输出数据域
        printf("%d\t",q->data);

        q = q->next;//指针指向下一数据域
    }
    putchar(10);
    printf("遍历结束\n");
}

7、通过位置查找节点

        1）参数：链表、位置

        2）返回值：目标节点的地址

        

//查找函数
NodePrt list_search(NodePrt L,int pos)
{
    if (NULL == L || list_empty(L) || pos < 0 || pos > L->len)
    {
        printf("查找失败\n");
        return NULL;
    }
    
    //查找逻辑
    //定义遍历指针从头节点出发,找目标节点
    NodePrt q = L;
    for (int i = 0; i < pos; i++)//如果为0就不需要偏移（找下一个数据域）
    {
        q = q->next;
    }
    
    return q;  //将找到节点地址返回
}

8、任意位置插入函数

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

        2）返回值：int

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

//任意位置插入
int list_insert_pos(NodePrt L,int pos,datatype e)
{
    
    if (NULL == L || pos < 1 || pos > L->len + 1)
    {
        printf("插入位置不合法\n");
        return-1;
    }
    
    NodePrt p = apply_node(e);
    if (NULL == p)
    {
        return -1;
    }
    

    NodePrt q = list_search(L,pos-1);//位置查找前驱节点（更新头节点）

    p->next = q->next;
    q->next = p;

    L->len++;

    printf("插入成功\n");

    return 0;
    
}

9、链表头删

        1）参数：链表

        2）返回值： int

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


//链表头删
int list_delete_head(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("头删失败\n");
        return -1;
    }
    
    NodePrt p = L->next;
    L->next = p->next;  //L->next->next;
    free(p);
    p =NULL;

    L->len--;

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

10、任意位置删除

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

        2）返回值：int

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

//任意位置删除
int list_delete_pos(NodePrt L,int pos)
{
    if (NULL == L || pos > L->len + 1 || pos < 1)
    {
        printf("删除失败\n");
        return -1;
    }

    NodePrt q = list_search(L,pos-1);

    NodePrt p = q->next;
    q->next = p->next;
    free(p);
    p = NULL;

    L->len--;
    printf("删除成功\n");
    return 0;
}

11、按值查找返回位置

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

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

// 按值查找
int list_search_value(NodePrt L, datatype e)
{
    if (NULL == L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }

    NodePrt q = L->next;
    for (int i = 1; i <= L->len; i++)
    {
        if (q->data == e)
        {
            return i;
        }

        q = q->next;
    }

    printf("值不存在\n");
    return -1;
}

12、按位置修改

        1）参数：链表、要修改的位置、要更新的值

        2）返回值：int

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

//按位置修改
int list_update_pos(NodePrt L,int pos,datatype e)
{
    if (NULL == L || pos < 1 || pos >L->len || list_empty(L))
    {
        printf("按位置修改失败\n");
        return -1;
    }
    
    // list_search_pos(L,pos)->data = e;

    NodePrt p = list_search(L,pos);

    p->data = e;
    printf("按位置修改成功\n");

    return 0;
}

13、按值进行修改函数

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

        2）返回值：int

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

//按值修改
int list_update_value(NodePrt 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)
    {
        return -1;
    }

    list_update_pos(L,res,new_e);
    
    printf("按值修改成功\n");
    return 0;
}

14、链表的反转

        1）参数：链表

        2）返回值：int

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

//反转
void list_reverse(NodePrt L)
{
    if (NULL == L || list_empty(L) || L->len <= 1)
    {
        printf("反转失败\n");
        return ;
    }
    
    NodePrt H = L->next;

    L->next = NULL;

    NodePrt p = H;

    while (H)
    {
        p = H;
        H = H->next;
        
        p->next = L->next;
        L->next = p;
    }
    printf("反转成功\n");
    return ;
}

//释放内存
void list_dsetroy(NodePrt L)
{
    if(NULL == L)
    {
        return;
    }

    while (!(list_empty(L)))
    {
        list_delete_head(L);
    }
    
    free(L);
    L = NULL;

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

}

15、链表的释放

        1）参数：链表

        2）返回值：无

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

//释放内存
void list_dsetroy(NodePrt L)
{
    if(NULL == L)
    {
        return;
    }

    while (!(list_empty(L)))
    {
        list_delete_head(L);
    }
    
    free(L);
    L = NULL;

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

}

16、排序

// 排序
int list_sort(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("排序失败\n");
        return -1;
    }

    // 遍历
    NodePrt q = L->next;
    NodePrt q1 = NULL;
    while (q)
    {
        q1 = q->next; // 重置指针位置
        while (q1)
        {
            if (q->data > q1->data) // 交换条件
            {
                datatype temp = q->data;
                q->data = q1->data;
                q1->data = temp;
            }

            q1 = q1->next; // 偏移
        }
        q = q->next; // 偏移
    }
    printf("排序成功\n");
    return 0;
}

17、去重

// 去重
int list_deduplication(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("去重失败\n");
        return -1;
    }
    
    list_sort(L);
    // 遍历
    
    NodePrt q = L->next;
    while (q)
    {
        NodePrt q1 = q->next; // 重置指针位置
        while (q1)
        {
            if (q->data == q1->data) // 判断
            {
                q1 = q->next;
                q->next = q1->next;
                free(q1);  
                q1 = NULL;
                
                L->len--;
                printf("重复值删除成功\n");

            }
            else
            {
                q1 = q1->next; // 偏移
            }
        }
        q = q->next; // 偏移
    }
    printf("去重成功\n");
    return 0;
}

18、去重（递归）

 19、有序的连接链表

完整代码

00.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, *NodePrt;

// 创建列表
NodePrt list_create();

// 申请节点 封装数据
NodePrt apply_node(datatype e);

// 判空
int list_empty(NodePrt L);

// 插入数据
// 头插
int list_inser_head(NodePrt L, datatype e);

// 链表遍历
int list_show(NodePrt L);

// 查找函数
NodePrt list_search(NodePrt L, int pos);

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

// 删除
// 链表头删
int list_delete_head(NodePrt L);

// 任意位置删除
int list_delete_pos(NodePrt L, int pos);

// 按值查找
int list_search_value(NodePrt L, datatype e);

//按位置修改
int list_update_pos(NodePrt L,int pos,datatype e);

//按值修改
int list_update_value(NodePrt L,datatype old_e,datatype new_e);

//反转
void list_reverse(NodePrt L);

//释放内存
void list_dsetroy(NodePrt L);

//排序
int list_sort(NodePrt L);

//去重
int list_deduplication(NodePrt L);

//反转（递归
void list_reverse_recursion(NodePrt L);
#endif // !LINKLIST_H

00.c

#include "00.h"

// 创建列表
NodePrt list_create()
{
    // 在堆区申请一个头节点
    NodePrt L = (NodePrt)malloc(sizeof(Node));
    if (NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }

    L->len = 0;
    L->next = NULL;

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

// 申请节点 封装数据
NodePrt apply_node(datatype e)
{
    // 申请节点大小
    NodePrt p = (NodePrt)malloc(sizeof(Node));
    if (NULL == p)
    {
        printf("节点创建失败\n");
        return NULL;
    }

    // 给节点赋值
    p->data = e;
    p->next = NULL;

    // printf("节点创建成功\n");
    return p;
}

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

// 插入数据
// 头插
int list_inser_head(NodePrt L, datatype e)
{
    if (NULL == L)
    {
        printf("链表不合法\n");
        return -1;
    }
    NodePrt 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(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }

    NodePrt q = L->next; // 定义遍历指针从第一个节点出发
    while (q)
    {
        // 输出数据域
        printf("%d\t", q->data);

        q = q->next; // 指针指向下一数据域
    }
    putchar(10);
    printf("遍历结束\n");
}

// 查找函数
NodePrt list_search(NodePrt L, int pos)
{
    if (NULL == L || list_empty(L) || pos < 0 || pos > L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    // 查找逻辑
    // 定义遍历指针从头节点出发,找目标节点
    NodePrt q = L;
    for (int i = 0; i < pos; i++) // 如果为0就不需要偏移（找下一个数据域）
    {
        q = q->next;
    }

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

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

    if (NULL == L || pos < 1 || pos > L->len + 1)
    {
        printf("插入位置不合法\n");
        return -1;
    }

    NodePrt p = apply_node(e);
    if (NULL == p)
    {
        return -1;
    }

    NodePrt q = list_search(L, pos - 1); // 位置查找前驱节点（更新头节点）

    p->next = q->next;
    q->next = p;

    L->len++;

    printf("插入成功\n");

    return 0;
}

// 链表头删
int list_delete_head(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("头删失败\n");
        return -1;
    }

    NodePrt p = L->next;
    L->next = p->next; // L->next->next;
    free(p);
    p = NULL;

    L->len--;

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

// 任意位置删除
int list_delete_pos(NodePrt L, int pos)
{
    if (NULL == L || pos > L->len + 1 || pos < 1)
    {
        printf("删除失败\n");
        return -1;
    }

    NodePrt q = list_search(L, pos - 1);

    NodePrt p = q->next;
    q->next = p->next;
    free(p);
    p = NULL;

    L->len--;
    printf("删除成功\n");
    return 0;
}

// 按值查找
int list_search_value(NodePrt L, datatype e)
{
    if (NULL == L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }

    NodePrt q = L->next;
    for (int i = 1; i <= L->len; i++)
    {
        if (q->data == e)
        {
            return i;
        }

        q = q->next;
    }

    printf("值不存在\n");
    return -1;
}

// 按位置修改
int list_update_pos(NodePrt L, int pos, datatype e)
{
    if (NULL == L || pos < 1 || pos > L->len || list_empty(L))
    {
        printf("按位置修改失败\n");
        return -1;
    }

    // list_search_pos(L,pos)->data = e;

    NodePrt p = list_search(L, pos);

    p->data = e;
    printf("按位置修改成功\n");

    return 0;
}

// 按值修改
int list_update_value(NodePrt 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)
    {
        return -1;
    }

    list_update_pos(L, res, new_e);

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

// 反转
void list_reverse(NodePrt L)
{
    if (NULL == L || list_empty(L) || L->len <= 1)
    {
        printf("反转失败\n");
        return;
    }

    NodePrt H = L->next;

    L->next = NULL;

    NodePrt p = H;

    while (H)
    {
        p = H;
        H = H->next;

        p->next = L->next;
        L->next = p;
    }
    printf("反转成功\n");
    return;
}

// 释放内存
void list_dsetroy(NodePrt L)
{
    if (NULL == L)
    {
        return;
    }

    while (!(list_empty(L)))
    {
        list_delete_head(L);
    }

    free(L);
    L = NULL;

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

// 排序
int list_sort(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("排序失败\n");
        return -1;
    }

    // 遍历
    NodePrt q = L->next;
    NodePrt q1 = NULL;
    while (q)
    {
        q1 = q->next; // 重置指针位置
        while (q1)
        {
            if (q->data > q1->data) // 交换条件
            {
                datatype temp = q->data;
                q->data = q1->data;
                q1->data = temp;
            }

            q1 = q1->next; // 偏移
        }
        q = q->next; // 偏移
    }
    printf("排序成功\n");
    return 0;
}

// 去重
int list_deduplication(NodePrt L)
{
    if (NULL == L || list_empty(L))
    {
        printf("去重失败\n");
        return -1;
    }
    
    list_sort(L);
    // 遍历
    
    NodePrt q = L->next;
    while (q)
    {
        NodePrt q1 = q->next; // 重置指针位置
        while (q1)
        {
            if (q->data == q1->data) // 判断
            {
                q1 = q->next;
                q->next = q1->next;
                free(q1);  
                q1 = NULL;
                
                L->len--;
                printf("重复值删除成功\n");

            }
            else
            {
                q1 = q1->next; // 偏移
            }
        }
        q = q->next; // 偏移
    }
    printf("去重成功\n");
    return 0;
}

/*// 反转（递归)
void list_reverse_recursion(NodePrt L)
{
    if (NULL == L || list_empty(L) || L->len <= 1)
    {
        printf("反转失败\n");
        return;
    }


}*/

00main.c

#include "00.h"

int main(int argc, char const *argv[])
{
    NodePrt L = list_create();
    if (NULL == L)
    {
        printf("error\n");
        return -1;
    }

    // 头插
    list_inser_head(L, 2024);
    list_inser_head(L, 2025);
    list_inser_head(L, 2027);
    list_inser_head(L, 2023);
    list_inser_head(L, 2025);
    list_inser_head(L, 2027);
    list_inser_head(L, 2023);

    // 遍历
    list_show(L);

    //任意位置插入
    list_insert_pos(L,2,2028);
    list_show(L);
    //尾插
    list_insert_pos(L,L->len+1,2030);
    list_show(L);

    // 头删
    list_delete_head(L);
    list_show(L);

    //任意位置删除
    list_delete_pos(L,3);
    list_show(L);

    //按值查找
    int res = list_search_value(L,2027);
    if (res != 0)
    {
        printf("该值在链表的第%d个位置\n",res+1);
    }

    //按位置修改
    list_update_pos(L,2,1234);
    list_show(L);

    //按值修改
    list_update_value(L,1234,2029);
    list_show(L);

    //反转
    list_reverse(L);
    list_show(L);
    
    //排序
    list_sort(L);
    list_show(L);

    //去重
    list_insert_pos(L,3,2023);
    list_insert_pos(L,4,2028);
    list_insert_pos(L,5,2029);
    list_show(L);
    list_deduplication(L);
    list_show(L);

    //反转（递归）
    // list_reverse_recursion(L);
    // list_show(L);
    
    //销毁
    list_dsetroy(L);
    L = NULL;
    list_show(L);


    return 0;
}

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

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

相关文章

VScode tab不能正常使用

VScode tab不能正常使用

现象不能够在文本编辑器中按下tab键&#xff0c;如果按下了&#xff0c;就焦点会跑到终端或者是其他地方&#xff0c;猜测是因为装了某些插件导致的。 解决方案比较简单&#xff1a; 删除掉其他的按键 比如这样的&#xff0c;保存就可以了
阅读更多...
mysql1055报错解决方法

mysql1055报错解决方法

目录 一、mysql版本 二、 问题描述 三、解决方法 1.方法一&#xff08;临时&#xff09; 2.方法二&#xff08;永久&#xff09; 一、mysql版本 mysql版本&#xff1a;5.7.23 二、 问题描述 在查询时使用group by语句&#xff0c;出现错误代码&#xff1a;1055&#xf…
阅读更多...
Facebook的创新之路：科技驱动的社交革命

Facebook的创新之路：科技驱动的社交革命

Facebook自2004年创立以来&#xff0c;已经从一个大学校园内的社交网站发展成为全球最大的社交媒体平台。其成功的背后&#xff0c;不仅仅是广泛的用户基础和高效的运营模式&#xff0c;更在于其不断推进的技术创新。本文将探讨Facebook在技术创新方面的诸多努力&#xff0c;如…
阅读更多...
MYSQL 六、mysql锁 1

MYSQL 六、mysql锁 1

一、概述 在数据库中&#xff0c;除传统的计算资源&#xff08;如CPU、RAM、I/O等&#xff09;的争用以外&#xff0c;数据也是一种供许多用户共享的 资源。为保证数据的一致性&#xff0c;需要对 并发操作进行控制 &#xff0c;因此产生了 锁 。同时 锁机制 也为实现MySQL 的各…
阅读更多...
GitHub Actions是什么

GitHub Actions是什么

目录 GitHub Actions是什么 GitHub Actions的使用方法 示例 注意事项 GitHub Actions配置文件中-工作流的 ：Workflow 一、自动化任务执行 二、规范团队协作 三、灵活配置和定制 四、提高开发效率 五、集成GitHub生态 六、可复用性和共享性 仓库中的“Actions”部分…
阅读更多...
新生上大学提前去西藏旅游有什么要注意的，语言上该怎么办？

新生上大学提前去西藏旅游有什么要注意的，语言上该怎么办？

新生前往西藏旅游并提前适应大学生活是一次充满挑战与发现的旅程。在准备过程中&#xff0c;重要的是要对高原反应有所准备&#xff0c;了解其症状并采取预防措施&#xff0c;同时携带必要的防晒和保暖衣物以应对极端的气候条件。在交通和饮食方面&#xff0c;选择安全可靠的选…
阅读更多...
奔跑利润如何释放？来看看怎么分析现货黄金的跟踪止损位

奔跑利润如何释放？来看看怎么分析现货黄金的跟踪止损位

跟踪止损位是现货黄金交易和资金管理中一个重要的概念。我们做现货黄金的时候&#xff0c;将仓位分成两部分&#xff08;或以上&#xff09;。第一部分&#xff0c;我们在首个目标位获利离场&#xff0c;剩下那部分就可以让它奔跑&#xff0c;看看市场会不会走出大行情&#xf…
阅读更多...
springboot系列十一:Thymeleaf

springboot系列十一:Thymeleaf

文章目录 官方文档基本介绍Thymeleaf机制说明Thymeleaf语法表达式运算符th属性迭代条件运算使用Thymeleaf th属性需要注意点 Thymeleaf综合案例需求说明思路分析代码实现 作业布置 官方文档 在线文档: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html 离线…
阅读更多...
自动导入unplugin-auto-import+unplugin-vue-components

自动导入unplugin-auto-import+unplugin-vue-components

文章介绍 接下来将会以Vite Vue3 TS的项目来举例实现 在我们进行项目开发时&#xff0c;无论是声明响应式数据使用的ref、reactive&#xff0c;或是各种生命周期&#xff0c;又或是computed、watch、watchEffect、provide-inject。这些都需要前置引入才能使用&#xff1a; …
阅读更多...
Mem0:个性化的AI记忆层，一款开源的大语言记忆增强工具

Mem0:个性化的AI记忆层，一款开源的大语言记忆增强工具

在人工智能的浪潮中&#xff0c;个性化体验已成为创新的关键。而随着各种各样的模型迭代更新&#xff0c;如何为AI应用提供持久、智能的记忆系统逐渐成为了一个关键挑战。 最近开源的Mem0项目为我们提供了一个强大的解决方案。它为大型语言模型(LLM)提供了一个智能、自我优化的…
阅读更多...
CTF ssrf 基础入门

CTF ssrf 基础入门

0x01 引言 我发现我其实并不是很明白这个东西&#xff0c;有些微妙&#xff0c;而且记忆中也就记得Gopherus这个工具了&#xff0c;所以重新学习了一下&#xff0c;顺便记录一下吧 0x02 辨别 我们拿到一个题目&#xff0c;他的名字可能就是题目类型&#xff0c;但是也有可能…
阅读更多...
昇思25天学习打卡营第九天|本地安装mindspore之一|Linux的系统在vmware上的安装以及mindspore的安装

昇思25天学习打卡营第九天|本地安装mindspore之一|Linux的系统在vmware上的安装以及mindspore的安装

课程已经学完了&#xff0c;打算再深入一些。初步的想法是&#xff0c;在本地安装&#xff0c;本地执行。 根据老师的指引&#xff0c;MindSpore官网&#xff0c;“https ://www.mindspore.cn/install/”&#xff0c;注意&#xff0c;因为csdn博客编辑器的原因&#xff0c;当我…
阅读更多...
C#与C++交互开发系列（三）：深入探讨P/Invoke基础知识

C#与C++交互开发系列（三）：深入探讨P/Invoke基础知识

欢迎来到C#与C交互开发系列的第三篇。在这篇博客中&#xff0c;我们将深入探讨P/Invoke&#xff08;Platform Invocation Services&#xff09;的基础知识。P/Invoke是C#调用非托管代码的一种机制&#xff0c;能够让C#直接调用C编写的动态链接库&#xff08;DLL&#xff09;中的…
阅读更多...
轻松翻译，你值得拥有的PDF翻译工具分享

轻松翻译，你值得拥有的PDF翻译工具分享

大家好&#xff0c;作为一名初入职场的小菜鸟&#xff0c;我发现了一个让我头疼不已的问题——那就是PDF文件的翻译。在全球化日益加剧的今天&#xff0c;我们经常会遇到需要阅读或者翻译外文PDF文件的情况。但PDF文件不同于Word或Excel&#xff0c;它通常不易直接编辑&#xf…
阅读更多...
C语言 | Leetcode C语言题解之第278题第一个错误的版本

C语言 | Leetcode C语言题解之第278题第一个错误的版本

题目&#xff1a; 题解&#xff1a; int firstBadVersion(int n) {int left 1, right n;while (left < right) { // 循环直至区间左右端点相同int mid left (right - left) / 2; // 防止计算时溢出if (isBadVersion(mid)) {right mid; // 答案在区间 [left, mid] 中…
阅读更多...
SWAT模型

SWAT模型

原文链接&#xff1a;SWAT模型https://mp.weixin.qq.com/s?__bizMzUzNTczMDMxMg&mid2247610033&idx2&snc1da9be73550928ecc6a7a165dda3d9c&chksmfa826f56cdf5e640f891c6977cec1b2728ee2554ceacd224903df73d2dfedcd0c8b9ec047843&token91118244&langzh…
阅读更多...
uniapp入门超详细教程：如何从零开始搭建项目

uniapp入门超详细教程：如何从零开始搭建项目

目录 一、介绍 二、环境搭建 2.1.需要下载的软件 2.1.1 HBuilderX 2.1.2 下载微信开发者工具 2.2 创建uniapp项目 2.2.1 新建项目 2.2.2 项目基本结构 2.2.3 在微信开发者工具上运行 2.2.4 发布微信小程序 三、pages.json 页面路由 四、组件 4.1 视图容器 4.1.1 v…
阅读更多...
超分AI模型学习

超分AI模型学习

概述 超分&#xff08;超分辨率&#xff1a;Super Resolution&#xff0c;SR&#xff09;&#xff1a;是计算机视觉和图像处理领域的一个热门话题。主要是将低分辨率图像恢复出高分辨率图像。可以采用的方法和手段很多&#xff0c;最近项目中有涉及&#xff08;红外成像的超分处…
阅读更多...
Axivion Suite 7.8现已发布

Axivion Suite 7.8现已发布

现已实现100%覆盖MISRA规则&#xff0c;并加入了高级功能来提高代码分析能力。 我们很高兴地宣布Axivion Suite 7.8发布。全新版本的Axivion Suite对编译器、配置、分析、仪表板 (WebUI)和IDE插件的架构验证和静态代码分析功能均进行了升级。 100%覆盖所有可测试的MISRA规则 …
阅读更多...
centos系统mysql集群复制双主双从

centos系统mysql集群复制双主双从

文章目录 MySQL 双主双从集群一、 准备环境二、 配置主服务器1. 配置 MySQL 主服务器 1 (192.168.1.1)2. 配置 MySQL 主服务器 2 (192.168.1.2) 三、配置从服务器1. 配置 MySQL 从服务器 1 (192.168.1.3)2. 配置 MySQL 从服务器 2 (192.168.1.4)3. 在主服务器 1 上配置复制到主…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023