算法库应用- 表的自然链接

已于 2024-04-16 00:29:46 修改
阅读量222 收藏 3
点赞数 2
分类专栏： 算法库应用 文章标签： 算法
于 2024-04-14 12:38:52 首次发布
本文链接：https://blog.csdn.net/qq_57484399/article/details/137741686
版权

功  能: 设计算法,将两个单链表数组的特定位序, 相同者,链接起来
编程人: 王涛
详细博客:https://blog.csdn.net/qq_57484399/article/details/127161982
时  间: 2024.4.14

版本更新日志:

版  本1.0日志: V1.0 基本功能

版  本2.0日志  :  增加直接数组处理 , 无需人工输入, 增加数组数据遍历

目录

V1.0

main.cpp

v1.0运行结果:

V2.0

更新功能

main.cpp

v2.0运行结果:

V1.0

main.cpp

/*****************************************
功  能: 设计算法,将两个单链表数组的特定位序, 相同者,链接起来
编程人: 王涛
详细博客:https://blog.csdn.net/qq_57484399/article/details/127161982
时  间: 2024.4.14
版  本: V1.0
******************************************/
#include <stdio.h>
#include <malloc.h>

#define MaxCol 10

typedef int ElemType;

typedef struct dataNode
{
    ElemType date[MaxCol];  //存储数据的节点数组
    struct dataNode *next;     //定义节点的前驱指针
}DataList;

typedef struct headNode
{
    int row;    //头结点数据存储链表的 行数和列数
    int columns;
    DataList *next;  //头结点的后继指针类型是 DataList

}HeadList;


void CreatTable(HeadList *&new_table)
{
    int i,j;
    DataList *tailNode; //尾指针节点
    DataList *dataNode; //数据新节点
    new_table = (HeadList*)malloc(sizeof(HeadList));
    new_table->next = NULL;//基本头结点创建成功
    //下面分配行列数
    printf("请输入表的行数和列数:");
    scanf("%d%d",&new_table->row,&new_table->columns);
    //头结点基本创建完成

    //下面遍历输入数据节点
    for(i = 0;i < new_table->row; i++)
    {
        printf("请输入第%d行的数据:",i+1);
        //为每行数组分配空间
        dataNode = (DataList*)malloc(sizeof(DataList));
        for(j = 0;j < new_table->columns; j++)
        {
            scanf("%d",&dataNode->date[j]);
        }
        //数据填充完毕, 开始 尾插法插入头结点之后(head和data节点类型不一致,区分插入)
        if(new_table->next == NULL)
        {
            new_table->next = dataNode;
        }
        else
        {
            tailNode->next = dataNode;
        }
        tailNode = dataNode;    //尾结点指向新节点
    }
     //尾指针置空
    tailNode->next = NULL;
}
/*****************************************
    //定义指针指向数据节点

    //while(数据节点不为空){


        //()for循环遍历数组

        //遍历完指针后移
    //}
    //记得换行回车
******************************************/
void DisplayTable(HeadList *showTable)
{
    int i;
    //定义指针指向数据节点
    dataNode *nowNode = showTable->next;
    //while(数据节点不为空){
    printf("\n");
    while(nowNode != NULL)
    {
        //()for循环遍历数组
        for(i = 0; i < showTable->columns; i++)
        {
            printf("%2d",nowNode->date[i]);
            printf(" ");
        }
        //记得换行回车
        printf("\n");
        printf("\n");
        //遍历完指针后移
        nowNode = nowNode->next;
    }

}



void LinkTable(HeadList *first_table,HeadList *second_table,HeadList *&result_table)
{
    DataList *firstNode;
    DataList *secondNode;
    DataList *newNode;
    DataList *tailNode;
    int connect_table1,connect_table2;
    int serial_number;  //数组序号
    //result_table 头节点建立好 (列 = first_table->columns + second_table->columns),行不确定
    result_table = (HeadList*)malloc(sizeof(HeadList));
    result_table->columns = first_table->columns + second_table->columns;
    result_table->row = 0;  //目前是0
    //然后头结点next置空
    result_table->next = NULL;
    //while 遍历 first_table每个节点 ,
    firstNode = first_table->next;
    secondNode = second_table->next;

    printf("表1连接的数组位序:");
    scanf("%d",&connect_table1);
    getchar();getchar();
    printf("表2连接的数组位序:");
    scanf("%d",&connect_table2);

    while(firstNode != NULL)
    {
            secondNode = second_table->next;//每次都重新遍历
            //拿first_table一个节点 遍历 second_table的所有节点
            while(secondNode != NULL)
            {
                //判断特定行,特定列, 相等,则链接相关数组for循环
                if(secondNode->date[connect_table2-1] == firstNode->date[connect_table1-1])
                {
                    newNode = (DataList*)malloc(sizeof(DataList));
                    //连接两数组(first先, second后)
                    for(serial_number = 0; serial_number < first_table->columns;serial_number++)
                    {
                        newNode->date[serial_number] = firstNode->date[serial_number];
                    }
                    for(serial_number = 0;serial_number < second_table->columns;serial_number++)
                    {
                        newNode->date[(first_table->columns)+serial_number] = secondNode->date[serial_number];
                    }
                    if(result_table->next == NULL)
                    {
                        result_table->next = newNode;
                    }
                    else
                    {
                        tailNode->next = newNode;
                    }

                    tailNode =  newNode;
                    result_table->row++;
                    //尾插法插入result_table后
                }
                secondNode = secondNode->next;
            }
            firstNode = firstNode->next;
    }
    //result_table尾结点 置空
    tailNode->next = NULL;
}

int main()
{

    HeadList *first_table;  //代表要处理第一个表
    HeadList *second_table; //代表第要处理二个表
    HeadList *result_table;  //两个表处理后,存储结果的表C


    printf("表1:\n");
    //用头结点建表
    CreatTable(first_table);
    printf("表2:\n");
    //头结点建表
    CreatTable(second_table);

    //处理两个表
    LinkTable(first_table,second_table,result_table);


    DisplayTable(result_table);
    return 0;
}

v1.0运行结果:

V2.0

更新功能

方便手打数组:

ElemType first[5][3] = {
        {3,2,3},
        {2,1,2},
        {4,2,4},
        {1,1,2},
        {5,2,1},
};

ElemType second[4][2] = {
         {2,1},
         {1,2},
         {5,3},
         {2,4},
};

增加的功能: 计算 所写数组的 行,列, 并把数组填充到指针数组里面 , 方便弹性传入函数

 ephemeral_row =  sizeof(first)/sizeof(first[0]);
 ephemeral_columns =  sizeof(first[0])/sizeof(first[0][0]);


 ElemType **Array_use = (ElemType **)malloc(ephemeral_row*sizeof(ElemType*));
 for(int i = 0; i < ephemeral_row; i++)
 {
   Array_use[i] = (ElemType *)malloc(ephemeral_columns *sizeof(ElemType));
   //填充数据
   for(int j = 0; j < ephemeral_columns; j++)
   {
      Array_use[i][j] = first[i][j];
   }
 }

 CreatTable_auto(first_table,Array_use,ephemeral_row,ephemeral_columns);

  1. 计算行列数: 您已经使用了 sizeof 运算符来计算数组的行数和列数，这是正确的。这里是您的代码：

    ephemeral_row = sizeof(first) / sizeof(first[0]);
ephemeral_columns = sizeof(first[0]) / sizeof(first[0][0]);

  2. 创建 CreatTable_auto 函数: 您需要修改 CreatTable_auto 函数，以便它可以接受一个指向指针的指针作为参数，这样就可以传入任意大小的二维数组。这里是修改后的函数原型：

    void CreatTable_auto(HeadList *&new_table, ElemType **Array_use, int row, int columns);

  3. 动态分配二维数组: 在调用 CreatTable_auto 之前，您需要动态创建一个二维数组。这里是如何做到这一点的示例代码：

    // 分配行指针
ElemType **Array_use = (ElemType **)malloc(ephemeral_row * sizeof(ElemType *));
for (int i = 0; i < ephemeral_row; i++) {
    // 为每一行分配列
    Array_use[i] = (ElemType *)malloc(ephemeral_columns * sizeof(ElemType));
    // 填充数据
    for (int j = 0; j < ephemeral_columns; j++) {
        Array_use[i][j] = first[i][j];
    }
}

空间分配:

解析:

在C语言中，当您使用 malloc 动态分配内存来创建一个二维数组时，内存的摆放方式如下：

  1. 行指针数组: 首先，您分配了一个行指针数组。这个数组包含了指向每一行的指针。这些指针是有序的，按照您分配它们的顺序排列。例如，Array_use[0] 将指向第一行，Array_use[1] 将指向第二行，依此类推。

  2. 行内存分配: 对于每一行，您又分配了一个数组来存储实际的数据。这些数据数组也是有序的，每个数组对应于行指针数组中的一个指针。

这种内存摆放方式可以用以下图示表示：

Array_use --> [ Ptr_Row0 | Ptr_Row1 | Ptr_Row2 | ... | Ptr_RowN ]
                |           |           |               |
                v           v           v               v
              [Data_Row0] [Data_Row1] [Data_Row2] ... [Data_RowN]

每个 Ptr_RowX 是一个指针，指向一个 Data_RowX，这是一个包含行数据的数组。

当您需要访问这些行地址时，您可以直接通过行指针数组进行索引。例如，如果您想访问第 i 行的第 j 个元素，您可以使用 Array_use[i][j]。这是因为 Array_use[i] 给出了第 i 行的起始地址，而 [j] 给出了从该行起始地址开始的第 j 个元素的偏移量。

请注意，虽然这些行指针是连续存储的，但每一行的数据可能不是连续存储的。每一行都是单独分配的，所以它们在内存中的位置可能是分散的。

建表函数:

void CreatTable_auto(HeadList *&new_table,ElemType **Array_use,int row,int columns)
{
    int i,j;
    DataList *tailNode; //尾指针节点
    DataList *dataNode; //数据新节点
    new_table = (HeadList*)malloc(sizeof(HeadList));
    new_table->next = NULL;//基本头结点创建成功
    //下面分配行列数
    //计算行数
    new_table->row = row;//计算行数

    new_table->columns = columns;//计算行数

    //头结点基本创建完成

    //下面遍历输入数据节点
    for(i = 0;i < new_table->row; i++)
    {
//        printf("请输入第%d行的数据:",i+1);
        //为每行数组分配空间
        dataNode = (DataList*)malloc(sizeof(DataList));
        for(j = 0;j < new_table->columns; j++)
        {
//            scanf("%d",&dataNode->date[j]);
            dataNode->date[j] = Array_use[i][j];
        }

        //数据填充完毕, 开始 尾插法插入头结点之后(head和data节点类型不一致,区分插入)
        if(new_table->next == NULL)
        {
            new_table->next = dataNode;
        }
        else
        {
            tailNode->next = dataNode;
        }
        tailNode = dataNode;    //尾结点指向新节点
    }
     //尾指针置空
    tailNode->next = NULL;
}

解析: 因为使用的是 数组指针, 所以可以弹性访问数组内数据, 不在在意不同行和列

main.cpp

/*****************************************
功  能: 设计算法,将两个单链表数组的特定位序, 相同者,链接起来
编程人: 王涛
详细博客:https://blog.csdn.net/qq_57484399/article/details/127161982
时  间: 2024.4.14
v2.0日志:增设非交互模式
版  本: V2.0
******************************************/
#include <stdio.h>
#include <malloc.h>

#define MaxCol 10



typedef int ElemType;

typedef struct dataNode
{
    ElemType date[MaxCol];  //存储数据的节点数组
    struct dataNode *next;     //定义节点的前驱指针
}DataList;

typedef struct headNode
{
    int row;    //头结点数据存储链表的 行数和列数
    int columns;
    DataList *next;  //头结点的后继指针类型是 DataList

}HeadList;

ElemType first[5][3] = {
        {3,2,3},
        {2,1,2},
        {4,2,4},
        {1,1,2},
        {5,2,1},
};

ElemType second[4][2] = {
         {2,1},
         {1,2},
         {5,3},
         {2,4},
};


void CreatTable(HeadList *&new_table)
{
    int i,j;
    DataList *tailNode; //尾指针节点
    DataList *dataNode; //数据新节点
    new_table = (HeadList*)malloc(sizeof(HeadList));
    new_table->next = NULL;//基本头结点创建成功
    //下面分配行列数
    printf("请输入表的行数和列数:");
    scanf("%d%d",&new_table->row,&new_table->columns);
    //头结点基本创建完成

    //下面遍历输入数据节点
    for(i = 0;i < new_table->row; i++)
    {
        printf("请输入第%d行的数据:",i+1);
        //为每行数组分配空间
        dataNode = (DataList*)malloc(sizeof(DataList));
        for(j = 0;j < new_table->columns; j++)
        {
            scanf("%d",&dataNode->date[j]);
        }
        //数据填充完毕, 开始 尾插法插入头结点之后(head和data节点类型不一致,区分插入)
        if(new_table->next == NULL)
        {
            new_table->next = dataNode;
        }
        else
        {
            tailNode->next = dataNode;
        }
        tailNode = dataNode;    //尾结点指向新节点
    }
     //尾指针置空
    tailNode->next = NULL;
}


void CreatTable_auto(HeadList *&new_table,ElemType **Array_use,int row,int columns)
{
    int i,j;
    DataList *tailNode; //尾指针节点
    DataList *dataNode; //数据新节点
    new_table = (HeadList*)malloc(sizeof(HeadList));
    new_table->next = NULL;//基本头结点创建成功
    //下面分配行列数
    //计算行数
    new_table->row = row;//计算行数

    new_table->columns = columns;//计算行数

    //头结点基本创建完成

    //下面遍历输入数据节点
    for(i = 0;i < new_table->row; i++)
    {
//        printf("请输入第%d行的数据:",i+1);
        //为每行数组分配空间
        dataNode = (DataList*)malloc(sizeof(DataList));
        for(j = 0;j < new_table->columns; j++)
        {
//            scanf("%d",&dataNode->date[j]);
            dataNode->date[j] = Array_use[i][j];
        }

        //数据填充完毕, 开始 尾插法插入头结点之后(head和data节点类型不一致,区分插入)
        if(new_table->next == NULL)
        {
            new_table->next = dataNode;
        }
        else
        {
            tailNode->next = dataNode;
        }
        tailNode = dataNode;    //尾结点指向新节点
    }
     //尾指针置空
    tailNode->next = NULL;
}
/*****************************************
    //定义指针指向数据节点

    //while(数据节点不为空){


        //()for循环遍历数组

        //遍历完指针后移
    //}
    //记得换行回车
******************************************/
void DisplayTable(HeadList *showTable)
{
    int i;
    //定义指针指向数据节点
    dataNode *nowNode = showTable->next;
    //while(数据节点不为空){
    printf("\n");
    while(nowNode != NULL)
    {
        //()for循环遍历数组
        for(i = 0; i < showTable->columns; i++)
        {
            printf("%2d",nowNode->date[i]);
            printf(" ");
        }
        //记得换行回车
        printf("\n");
        printf("\n");
        //遍历完指针后移
        nowNode = nowNode->next;
    }

}



void LinkTable(HeadList *first_table,HeadList *second_table,HeadList *&result_table)
{
    DataList *firstNode;
    DataList *secondNode;
    DataList *newNode;
    DataList *tailNode;
    int connect_table1,connect_table2;
    int serial_number;  //数组序号
    //result_table 头节点建立好 (列 = first_table->columns + second_table->columns),行不确定
    result_table = (HeadList*)malloc(sizeof(HeadList));
    result_table->columns = first_table->columns + second_table->columns;
    result_table->row = 0;  //目前是0
    //然后头结点next置空
    result_table->next = NULL;
    //while 遍历 first_table每个节点 ,
    firstNode = first_table->next;
    secondNode = second_table->next;

    printf("表1连接的数组位序:");
    scanf("%d",&connect_table1);
    printf("表2连接的数组位序:");
    scanf("%d",&connect_table2);

    while(firstNode != NULL)
    {
            secondNode = second_table->next;//每次都重新遍历
            //拿first_table一个节点 遍历 second_table的所有节点
            while(secondNode != NULL)
            {
                //判断特定行,特定列, 相等,则链接相关数组for循环
                if(secondNode->date[connect_table2-1] == firstNode->date[connect_table1-1])
                {
                    newNode = (DataList*)malloc(sizeof(DataList));
                    //连接两数组(first先, second后)
                    for(serial_number = 0; serial_number < first_table->columns;serial_number++)
                    {
                        newNode->date[serial_number] = firstNode->date[serial_number];
                    }
                    for(serial_number = 0;serial_number < second_table->columns;serial_number++)
                    {
                        newNode->date[(first_table->columns)+serial_number] = secondNode->date[serial_number];
                    }
                    if(result_table->next == NULL)
                    {
                        result_table->next = newNode;
                    }
                    else
                    {
                        tailNode->next = newNode;
                    }

                    tailNode =  newNode;
                    result_table->row++;
                    //尾插法插入result_table后
                }
                secondNode = secondNode->next;
            }
            firstNode = firstNode->next;
    }
    //result_table尾结点 置空
    tailNode->next = NULL;
}

int main()
{

    HeadList *first_table;  //代表要处理第一个表
    HeadList *second_table; //代表第要处理二个表
    HeadList *result_table;  //两个表处理后,存储结果的表C
    int ephemeral_row;
    int ephemeral_columns;
    int mode;

    printf("请问您需要交互式,还是 直接处理数据呢? 1:交互  2:手写数组\n\n");
    scanf("%d",&mode);
    if(mode == 1)
    {
        printf("表1:\n");
        //用头结点建表
        CreatTable(first_table);
        printf("表2:\n");
        //头结点建表
        CreatTable(second_table);
    }
    else if(mode == 2)
    {
        ephemeral_row =  sizeof(first)/sizeof(first[0]);
        ephemeral_columns =  sizeof(first[0])/sizeof(first[0][0]);


        ElemType **Array_use = (ElemType **)malloc(ephemeral_row*sizeof(ElemType*));
        for(int i = 0; i < ephemeral_row; i++)
        {
            Array_use[i] = (ElemType *)malloc(ephemeral_columns *sizeof(ElemType));
            //填充数据
            for(int j = 0; j < ephemeral_columns; j++)
            {
                    Array_use[i][j] = first[i][j];
            }
        }

        CreatTable_auto(first_table,Array_use,ephemeral_row,ephemeral_columns);



        DisplayTable(first_table);
        ephemeral_row =  sizeof(second)/sizeof(second[0]);
        ephemeral_columns =  sizeof(second[0])/sizeof(second[0][0]);

        ElemType **Array_use1 = (ElemType **)malloc(ephemeral_row*sizeof(ElemType*));
        for(int i = 0; i < ephemeral_row; i++)
        {
            Array_use1[i] = (ElemType *)malloc(ephemeral_columns *sizeof(ElemType));
            //填充数据
            for(int j = 0; j < ephemeral_columns; j++)
            {
                    Array_use1[i][j] = second[i][j];
            }
        }

        CreatTable_auto(second_table,Array_use1,ephemeral_row,ephemeral_columns);
        DisplayTable(second_table);
    }

    //处理两个表
    LinkTable(first_table,second_table,result_table);

    printf("处理完后:\n\n");
    DisplayTable(result_table);
    return 0;
}

v2.0运行结果:

无数碎片寻你
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数学建模-32种常用算法汇总
qq_51533426的博客
03-20 3260
基础算法：如搜索算法（深度优先搜索、广度优先搜索）、排序算法（快速排序、归并排序、堆排序等）、贪心算法、动态规划等。 数值计算方法：如常微分方程数值解法（欧拉法、龙格库塔法等）、偏微分方程数值解法（有限差分法、有限元法等）、插值与拟合等。 最优化算法：如线性规划、非线性规划、整数规划、随机模拟退火算法、遗传算法、模拟退火算法等。 统计分析方法：如回归分析、方差分析、时间序列分析、聚类分析、主成分分析等。 图论算法：如最短路算法（Dijkstra算法、Floyd算法等）、最小生成树算法（Prim算法、
《机器学习-原理、算法与应用》出版了
SIGAI_CSDN的博客
11-07 6936
为什么要写本书？ 本书的前身为《机器学习与应用》，雷明著，清华大学出版社。在第一版的基础上做了大幅度优化，并经过反复校对，最终形成此书。由于之前是第一次写书，缺乏经验，导致了书的内容过多，里面存在大量开源库代码占据篇幅。这一版改进了这些问题，且增加了不少新的内容，更为系统和全面，品质也得到了不小的提升。 SIGAI微信公众号自去年4月份发布第一篇文章“机器学习-波澜壮阔40年”起，到今天为止，已...
TF-IDF算法介绍及实现
热门推荐
Asia-Lee
08-07 29万+
目录 1、TF-IDF算法介绍 （1）TF是词频(Term Frequency) （2） IDF是逆向文件频率(Inverse Document Frequency) （3）TF-IDF实际上是：TF * IDF 2、TF-IDF应用 3、Python3实现TF-IDF算法 4、NLTK实现TF-IDF算法 5、Sklearn实现TF-IDF算法 6、Jieba实现TF-IDF算...
TF-IDF算法讲解
qq_45893319的博客
07-31 4万+
什么是 TF-IDF 算法？ TF（全称TermFrequency），中文含义词频，简单理解就是关键词出现在网页当中的频次。 IDF（全称InverseDocumentFrequency），中文含义逆文档频率，简单来说就是该关键词出现在所有文档里面的一种数据集合。 在信息检索中，tf-idf或TFIDF（术语频率 – 逆文档频率的缩写）是一种数字统计，旨在反映单词对集合或语料库中的文档的重要程度。 它经常被用作搜索信息检索，文本挖掘和用户建模的加权因子。tf-idf值按比例增加一个单词出现在文档中的次数，并
【NLP-00】TF-IDF算法：原理、应用与介绍
qq_38614074的博客
03-06 1838
介绍tf-idf的实现原理和应用领域
用通俗易懂的方式讲解：TF-IDF算法介绍及实现
2201_75499313的博客
12-16 2587
TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。
NLP算法-关键词提取之Jieba算法库
Albert_weiku的博客
10-25 2603
为了方便用户快速了解文章的中心主题，会抽取文章的一些中心词来表达文章的中心思想。**关键词抽取就是通过一定的方法抽取出能表达文章的中心主题的一系列方法**。 在信息爆炸的时代，很多信息我们无法全面接收，我们需要从中筛选出一些我们感兴趣的或者说对我们有用的信息进行接收。怎么选择呢，关键词提取就是其中一个很好的方法。如果我们可以准确地将所有文档都用几个简单的关键词描述出来，单看几个关键词就可以了解一篇文章，这样会大大提高我们的信息获取效率。
【粉丝福利社】互联网大厂推荐算法实战（文末送书-完结）
时光隧道
01-12 4万+
算法是解决特定问题的一系列清晰、有限、可执行的步骤。它是计算机科学和数学领域中的基本概念之一。算法可以在计算机程序的指导下完成任务，可以用来解决各种问题，例如排序、搜索、图形处理等。算法的设计和分析是计算机科学的重要研究领域，目的是找到解决问题的最佳方法，以最高的效率和最低的资源消耗完成任务。算法的效率一般用时间复杂度和空间复杂度来衡量。推荐算法是一种利用用户的历史行为数据、用户个人信息、商品特征等多种信息，以预测用户可能感兴趣的商品或内容，并向用户提供个性化推荐的方法。
遗传算法——基于Big Mart Sales数据集的TPOT库实现（python）
定期分享我的发现和想法，感谢你的陪伴和支持
01-04 6118
实际上，AML 是在 scikit-learn 中应用的网格搜索的扩展，而不是迭代这些值预先定义的集合和其组合，它通过搜索方法，特征，变换和参数值来获得最佳解决方案。因此，AML“网格搜索”不需要在可能的配置空间上进行详尽的搜索 - AML 有一个很赞的应用叫做 TPOT 包，其提供了像遗传算法这样的应用，可用来在某个配置中混合各个参数并达到最佳设置。该步骤是遗传算法中产生新的个体的主要操作过程，它用一定的交配概率阈值(pc，一般是0.4到0.99)来控制是否采取单点交叉，多点交叉等方式生成新的交叉个体。
机器学习算法应用场景实例六十则
古月哲亭
12-17 1万+
原文链接：https://blog.csdn.net/liulingyuan6/article/details/53648273本文整理了60个机器学习算法应用场景实例，含分类算法应用场景20个、回归算法应用场景20个、聚类算法应用场景10个以及关联规则应用场景10个。包含了天池、DataCastle、DataFountain中所有竞赛场景。目录1 分类算法应用场景实例1.1 O2O优惠券使用预测1.2 市民出行选乘公交预测1.3待测微生物种类判别1.4 基于运营商数据的个人征信评估1.5 商品图片分类1.
hello-algo-数据结构与算法-zh-csharp.pdf
01-24
算法是指解决问题的步骤或过程，它可以是数学公式、流程图、自然语言描述等形式。算法的学习可以帮助读者更好地理解问题的解决思路和方法，从而提高编程能力和解决问题的能力。 本书的内容涵盖了数据结构与算法的...
python实现鸢尾花三种聚类算法（K-means,AGNES,DBScan）
09-19
【Python实现鸢尾花聚类算法】 聚类是无监督学习的一种重要方法，主要用于发现数据集中的自然分组。...对于鸢尾花数据集，通过Python的`sklearn`库，我们可以方便地实现这些算法，并通过可视化结果进行分析和比较。
java笔试题算法-reservoir:水库
06-03
java笔试题算法水库 所有伟人都有简单的开端。一个包含所有资源的库，可以在程序员遇到困难或开始新事物时提供帮助。 入门 在我们汇集的资源的帮助下，开始您想做的任何事情。欢迎您！ 基本工具和命令行 Python编程 ...
人工免疫遗传算法程序--改进的遗传算法.zip
04-10
在MATLAB中实现人工免疫遗传算法，可以利用其丰富的数学函数库和便捷的编程环境，使得算法的开发和调试更为高效。 人工免疫系统（Artificial Immune System, AIS）是受生物免疫机制启发的一种计算模型，主要包括...
java-chatbot:使用向后链接算法的ChatBot
05-02
这个项目是关于构建一个基于Java的聊天机器人，特别采用向后链接算法来处理自然语言对话。向后链接算法是一种在第一阶逻辑推理系统中广泛应用的方法，常用于人工智能和知识表示领域。此ChatBot专门设计用于针对选定...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 190
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 424
算法014：找到字符串中所有字母异位词
排序算法(4)之快速排序(1)
最新发布
wer24_25的博客
07-17 703
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 42
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
自然语言处理及算法_186
11-08
这份文档涵盖了从基础概念到实际应用的广泛内容，旨在帮助读者理解和掌握NLP（自然语言处理）领域的重要算法。 1. **Textrank算法**：作为文本摘要和热点人物分析的一种方法，Textrank借鉴了PageRank的思想，通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值