精华内容
下载资源
问答
  • 内容推荐算法python
    千次阅读
    2022-03-16 22:04:57

            多目标跟踪问题中都会遇到多个目标在两帧之间的匹配问题,这种多对多的匹配问题一般会使用匈牙利算法解决。匈牙利算法,本身解决的是一个指派问题。

    指派问题描述:

            实际中,会遇到这样的问题,有 m 项不同的任务,需要 n 个人分别完成其中的1项,每个人完成任务的时间不一样。于是就有一个问题,如何分配任务使得花费时间最少。转换到多目标跟踪中即可描述为:待跟踪匹配目标为 m 个,当前帧检测到 n 个目标,已知 m 个目标和 n 个检测结果之间的距离,求最有匹配,使得距离误差累计最小。

            如下表所示:

            通俗来讲,就是 m*n 矩阵中,选取 min(m,n) 个元素,每行每列各有1个元素,使得和最小。如果是求和最小问题,那么这个矩阵就叫做花费矩阵(Cost Matrix);如果要是使求和最大化,那么这个矩阵就叫做利益矩阵(Profit Matrix)。

    代码实现:

    from scipy.optimize import linear_sum_assignment
    import numpy as np
    
    cost = np.array([[0.64, 1.63, 3.95, 4.09, 4.48],
                     [3.95, 4.48, 0.73, 0.23, 2.26],
                     [0.42, 0.70, 4.24, 4.56, 4.35],
                     [3.73, 3.84, 1.07, 1.95, 0.85],
                     [4.37, 5.02, 1.60, 0.73, 3.48]])
                     
    row_ind, col_ind = linear_sum_assignment(cost)
    print('row_ind:', row_ind)  # 开销矩阵对应的行索引
    print('col_ind:', col_ind)  # 对应行索引的最优指派的列索引
    print('cost:', cost[row_ind, col_ind])  # 提取每个行索引的最优指派列索引所在的元素,形成数组
    print('cost_sum:', cost[row_ind, col_ind].sum())  # 最小开销

    结果:

    row_ind: [0 1 2 3 4] 
    col_ind: [0 2 1 4 3] 
    cost: [0.64 0.73 0.7 0.85 0.73] 
    cost_sum: 3.65

            矩阵中,行为目标,列为当前检测到待匹配框,可以看到仅使用最小距离,匹配结果为:0->0,1->3,2->0,3->4,4->3,0号、2号目标匹配到同一结果0,1号、3号目标匹配到同一结果3,存在一对多的情况。

            经过最小化花费,匈牙利算法结果为:0->0,1->2,2->1,3->4,4->3,达到全局最优。

    PS:该函数在m != n时,同样适用!

    更多相关内容
  • 一、简介:推荐系统是最常见的数据分析应用之一,包含淘宝、豆瓣、今日头条都是利用推荐系统来推荐用户内容推荐算法的方式分为两种,一种是根据用户推荐,一种是根据商品推荐,根据用户推荐主要是找出和这个用户...

    一、简介:

    推荐系统是最常见的数据分析应用之一,包含淘宝、豆瓣、今日头条都是利用推荐系统来推荐用户内容。推荐算法的方式分为两种,一种是根据用户推荐,一种是根据商品推荐,根据用户推荐主要是找出和这个用户兴趣相近的其他用户,再推荐其他用户也喜欢的东西给这个用户,而根据商品推荐则是根据喜欢这个商品的人也喜欢哪些商品区进行推荐,现在很多是基于这两种算法去进行混合应用。本文会用python演示第一种算法,目标是对用户推荐电影。

    二、获取数据:

    在movielens上,有许多的用户对电影评价数据,可以至(https://grouplens.org/datasets/movielens/)进行下载,下载完后打开资料夹,有个叫u.data的资料夹,打开会看到以下的数据

    1538108-20181120164908844-943335514.png

    第一列代表用户ID,第二列代表电影的ID,第三列代表评分(1-5分),第四列是时间戳

    三、数据预处理

    拿到了原始数据后,我们会发现几个问题,就是1、我根本不需要时间戳。2、同一个用户的评价散落在不连续好几行,不好进行分析。这个时候我们就需要进行数据的预处理,首先观察这份数据发现由于每个用户评价的电影都不相同,可能在200部里随机挑了5-10部来评分,所以如果用表格来显示的话会有很多的空格,这个时候KV型数据储存方式就很好用,利用一个键(key)对应一个值(value),这个时候就可以利用python的字典(dict),他可以记录键值对应。举例来说,我用户ID为"941’的用户,对电影ID为"763’的评价是3分,那我只需要储存【941】【763】=3这样就可以了,并把user合并,让界面更美观,如下图

    1538108-20181121112420112-1676726873.png

    可以看到我把用户ID为"941’评价的电影都列了出来,后面还跟了评分值,这样我后面在做分析的时候读取数据就比较方便了,下面是数据读取到处理的代码

    defload_data():

    f= open('u.data')

    user_list={}for line inf:

    (user,movie,rating,ts)= line.split(' ')

    user_list.setdefault(user,{})

    user_list[user][movie]=float(rating)return user_list

    user_list就是我们建立用来分析的名单

    三、算法:

    这边是使用最简单的欧几里得距离算法,简单来说就是将两人对同一部电影的评价相减平方再开根号,比如A看了蝙蝠侠给了5分,B看了给了5分,但C看了给分,AB距离是0, AC距离是2,可以得知A和B的喜好比较相近,当然现在推荐系统算法很多,这边只是挑了一个比较简单的算法,下面是算法的代码

    defcalculate():

    list=load_data()

    user_diff={}for movies in list['7']:for people inlist.keys():

    user_diff.setdefault(people,{})for item inlist[people].keys():if item ==movies:

    diff= sqrt(pow(list['7'][movies] - list[people][item],2))

    user_diff[people][item]=diffreturn user_diff

    这边挑了其中一位ID为7的用户,我的任务是帮他找出他可能会感兴趣的电影,所以先计算所有用户跟7的距离,由于7跟其他用户都看了不同的电影,所以要先找出共同看过的电影再将所有电影的距离列出来。

    接下来再把所有电影的距离取平均值,由于我们想知道的是相似度,相似度与平均值成反比,所以我们将距离倒过来就是相似度,另外为了让相似度这个数介于0~1,所以用了1/(1+距离)这个算法,以下为代码

    defpeople_rating():

    user_diff=calculate()

    rating={}for people inuser_diff.keys():

    rating.setdefault(people,{})

    a=0

    b=0for score inuser_diff[people].values():

    a+=score

    b+=1rating[people]= float(1/(1+(a/b)))return rating

    可以看到虽然代码有点丑,不过还是可以跑出个结果,下面就是结果,可以看到跟所有用户的相似度,可以看到跟ID为12的用户相似度为0.58, 跟ID为258的用户相似度为0.333

    1538108-20181121161053615-2072913872.png

    现在就是要从这里面找出几个相似度比较高的用户,也很简单,利用sort排个序,再选出前五个,下面为代码

    deftop_list():

    list=people_rating()

    items=list.items()

    top= [[v[1],v[0]] for v initems]

    top.sort(reverse=True)print(top[0:5])

    下面为结果

    1538108-20181121161513713-1177420745.png

    可以看到第一名就是他自己,然后547和384也和他非常契合,不过45名的相似度就下降的非常的快,现在我们来检视547跟384的菜单吧

    1538108-20181121161821511-363825604.png

    我们先来验证一下547跟384跟我们7号用户的相似度为什么这么高,下面代码可以找出547跟7号用户共同看过的电影跟评分

    list =load_data()for k,v in list['7'].items():for kk,vv in list['547'].items():if k ==kk:print(k,v,kk,vv)

    跑出来的结果如下

    1538108-20181121162051090-626895347.png

    原来他们只共同看了三部电影,给的评分还一样,所以距离才为0

    再用同样方法来看384跟7号

    1538108-20181121162258707-1209366850.png

    可以看到他们也是刚好看了3部一样的电影,给的分数也是一样,有趣的事他们三个都看了ID为258的电影,也都给了4分

    接下来就是最后一步了,我们要找出547和384看过但7号没看过的电影,再从里面找出评分高的推荐给7号,下面为代码

    deffind_rec():

    rec_list=top_list()

    first= rec_list[1][1]

    second= rec_list[2][1]

    all_list=load_data()for k,v inall_list[first].items():if k not in all_list['7'].keys() and v == 5:print(k)for k,v inall_list[second].items():if k not in all_list['7'].keys() and v == 5:print (k)

    最后跑出来的结果为

    1538108-20181121164823609-1773147061.png

    以上为547跟384的推荐名单,可以看到316/302/313都是两人共同推荐,代表这三部片应该是很好看,所以如果要推荐给7号用户的话可以选择这三片来推荐。

    四、总结

    在演练的过程里面我们可以看出这个算法的许多缺点,例如最高分的其实是因为他们共同看过的电影少,分数又刚好相同,很难说明这就是有共同的兴趣,然后相似度的落差太大,前两名都是1,三四名就掉到了0.75,可见三四名应该是与7号共同看过4部电影,但有其中一部的评分差了一分,导致分数骤降,而大部分的用户都集中在0.3-0,5之间,分数曲线极度不平滑。虽然有这些缺点,但这些算出来的推荐结果还是有代表了一定的意义,至少可以代表是与7号用户品味相似的人给出的高分电影,而7号尚未给过评分。

    展开全文
  • python实现基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法 基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法实现原理、公式、思路在前文中已有介绍,本次不再详细描述。本文主要是使用python语言...

    python实现基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法

    基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法实现原理、公式、思路在前文中已有介绍,本次不再详细描述。本文主要是使用python语言实现推荐算法,python语言有很多工具模块便于实现推荐算法,本文没有大量使用已有的机器学习模块,更多的是使用python的基础语法实现,注释详细,代码阅读性好,便于学习。

    python版本3.8,movielens数据集,943个用户,1682部电影,8万条评分数据。

    一、项目目录

    项目目录

    二、基于用户的协同过滤推荐算法

    1、算法原理:构建用户项目评分矩阵、计算用户之间的相似度、得到目标用户的最近邻居、预测评分、推荐
    2、读取评分数据,构建用户-项目评分矩阵读取评分数据,构建用户-项目评分矩阵
    3、用户-项目评分矩阵模块
    用户-项目评分矩阵模块
    这个模块是保存用户项目评分数据,同时分析数据,打印输出分析结果
    4、计算用户之间的相似度模块
    计算用户之间的相似度模块
    这个模块是计算用户之间的相似度,调用了余弦算法相似度模块
    5、得到目标用户的最近邻居模块
    得到目标用户的最近邻居模块
    这个模块是相似度排序,找到前N个相似度最大的用户,也可以设置相似度阀值来判定最近邻居
    6、预测评分、推荐模块
    预测评分、推荐模块
    7、测评指标MAE模块
    测评指标MAE模块
    8、运行结果
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    二、基于项目的协同过滤推荐算法

    1、算法原理:构建用户项目评分矩阵、计算项目之间的相似度、预测评分、推荐
    2、计算项目之间的相似度模块
    计算项目之间的相似度模块
    3、预测评分、推荐模块
    预测评分、推荐模块
    4、运行结果
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    作者专业长期研究各种协同过滤推荐算法,欢迎留言、私信互相交流学习,后续会不断更新不同的协同过滤推荐算法,欢迎关注。
    展开全文
  • 粒子群优化算法python实现

    千次阅读 2022-04-12 18:29:52
    粒子群优化算法(Particle Swarm Optimization, PSO)作为进化计算的一个分支,是由Eberhart和Kennedy于1995年提出的一种全局搜索算法,同时它也是一种模拟自然界的生物活动以及群体智能的随即搜索算法


    前言

    首先简单介绍粒子群优化算法,粒子群优化算法的python实现(含代码)


    一、粒子群优化算法是什么?

    粒子群优化算法(Particle Swarm Optimization, PSO)作为进化计算的一个分支,是由Eberhart和Kennedy于1995年提出的一种全局搜索算法,同时它也是一种模拟自然界的生物活动以及群体智能的随即搜索算法。
    粒子群优化算法起源于鸟群觅食的过程,一个核心机制是每只小鸟各自觅食,并记住一个离食物最近的位置,通过和其他的小鸟交流,得到整个鸟群已知的最佳位置,引导鸟群朝着这个方向继续搜索。
    还有两个关键设置:粒子历史最优位置(pBest向量)、群体历史最优位置(gBest向量)
    这里pBest向量是一组向量,它包含了每个粒子的历史最优位置,gBest向量为pBest向量中适应值最高的向量,即全局最优。
    说明:算法中一般取要优化的目标函数作为适应值函数,评估适应值的大小,然后更新pBest向量和gBest向量。

    二、算法流程

    (1)初始化所有个体(粒子),初始化它们的速度和位置,并且将个体的历史最优位置pBest设为当前位置,而群体中最优的个体作为当前的gBest。
    (2)在每一代的进化中,计算各个粒子的适应度函数值。
    (3)如果该粒子当前的适应度函数值比其历史最优值要好,那么历史最优将会被当前位置所代替。
    (4)如果该粒子的历史最优比全局最优要好,那么全局最优将会被该粒子的历史最优所替代。
    (5)对每个粒子i的第d维的速度和位置分别按照下列公式进行更新。这两个公式在二维空间中的关系如下图。
    在这里插入图片描述
    速度分量更新公式
    位置分量更新公式
    ω是惯量权重,一般初始化为0.9,随着迭代过程线性递减到0.4 ; c1和c2是加速系数(也称学习因子),传统上取固定值2.0 ; rand1d是和rand2d是两个[0,1]之间的随机数。另外,设置一个Vmax限制速度的范围,Vmax的每一维Vmaxd一般取相应维的取值范围的10%~20%。更新后检查位置是否在问题空间内。
    这里ω做一个线性递减是因为,在算法一开始,群体没有一个方向做指导,所以需要一个任意性,进行搜索;而随着算法的迭代,群体已经有了一个指导方向,就不再需要很大的任意性,而是受个体历史最优和群体历史最优的影响越来越大。
    (6)如果还没有到达结束条件,转到(2),否则输出gBest并结束。
    下图为算法的流程图。
    算法流程图

    三、算法的python实现

    本算法以优化目标函数:
    在这里插入图片描述
    为例,使用粒子群优化算法进行求解。
    运行环境:python3.6,jupyter notebook

    # 目标函数值计算
    def f(C):
        return 1/(C[0]**2+C[1]**2+C[2]**2+C[3]**2+1)
    # 初始化种群 C=[[[x],[v]]]
    def init(N):
        C = np.zeros((N,2,4))
        global pBest,gBest
        for i in range(N):
            for j in range(4):
                C[i][0][j] = np.random.uniform(-5,5)
                C[i][1][j] = np.random.uniform(-1,1)
            pBest[i] = C[i][0]
        gBest = pBest[np.argmax(Eval(C,N))].copy()
        return C
    # 判断更新后是否还在问题空间内
    def whether_out(C):
        for i in range(len(C)):
            for j in range(4):
                if C[i][0][j] < -5 :
                    C[i][0][j] = -5
                elif C[i][0][j] > 5:
                    C[i][0][j] = 5
        return C
    
    # 更新粒子的速度和位置
    def update_C(C,N,w,c1,c2):
        '''
        C:种群 [[[x],[v]]]
        N:种群规模 100
        w:惯量权重 初始0.9,递减到0.4
        c1、c2:加速系数
        pBest: 每个粒子的历史最优位置[[x]]
        gBest: 全局最优位置[x]
        '''
    #     print(C.shape)
        for i in range(N):
            for j in range(4):
                rand1 = np.random.random()
                rand2 = np.random.random()
                C[i][1][j] = w*C[i][1][j]+c1*rand1*(pBest[i][j]-C[i][0][j])+c2*rand2*(gBest[j]-C[i][0][j])
                C[i][0][j] +=  C[i][1][j]
        C = whether_out(C)
        return C
            
    # 评估函数
    def Eval(C,N):
        temp = np.array([])
        for i in range(N):
            temp = np.append(temp,f(C[i][0]))
        return temp
    # 更新粒子的历史最优和全局最优
    def update_best(C,N,fitness):
        '''
        pBest: 每个粒子的历史最优位置,[[x]]
        gBest: 全局最优位置,[x]
        fitness: 粒子当前适应值,[f(x)]
        '''
        global pBest,gBest
        for i in range(N):
            if fitness[i] > f(pBest[i]):
                pBest[i] = C[i][0]
            if fitness[i] > f(gBest):
                gBest = C[i][0].copy()
    # w线性递减
    def w_degression(w,N):
        w -= 0.5/N
        return w
    
    def PSO(length,N,w,c1,c2):
        global pBest,gBest
        C = init(N)
    #     print('gBest:',gBest)
        for i in range(length):
            C = update_C(C,N,w,c1,c2)
            fitness = Eval(C,N)
            update_best(C,N,fitness)
            w=w_degression(w,N)
            if f(gBest)==1.0:
                break
        return [f(gBest),gBest,i]
    
    start = time.time()
    c1,c2 = 2,2
    # length:迭代次数,N:种群规模
    length,N=1000,30
    w=0.9
    pBest = np.zeros((N,4))
    gBest = np.zeros(N)
    # PSO(length,N,w,c1,c2)
    end = time.time()
    print(PSO(length,N,w,c1,c2))
    print('PSO运行时间: %.2f s'%(end-start))
    

    实验结果

    当种群数设置为100时
    在这里插入图片描述
    当种群数设置为30时
    在这里插入图片描述

    展开全文
  • Python+Django+Mysql个性化二手车推荐系统 汽车推荐系统 基于用户、项目、内容的协同过滤推荐算法 WebCarCFRSPython python实现协同过滤推荐算法实现源代码下载 一、项目简介 1、开发工具和实现技术 Python3.8,...
  • 基于Python3的社区发现算法fast_unfolding,已经对其中的bug进行修改
  • 遗传算法-python版(计算机智能算法)

    千次阅读 2021-09-27 09:55:41
    前言: 遗传算法的原理及python实现 一、原理 二、整体步骤 三、算法实例 四、编程实现
  • Python+Django+Mysql在线新闻推荐系统 个性化新闻推荐 基于用户、项目、内容的协同过滤推荐算法 WebNewsCFRSPython python实现协同过滤推荐算法实现源代码下载 一、项目简介 1、开发工具和实现技术 Python3.8,...
  • 在程序中我直接使用了u.data这个数据集,可以直接从文件夹“数据”获取,验证了UserBasedCF算法的实际效果,程序设计思路主要来源于项亮博士的《推荐系统》42-50页的内容,可以作为参考。程序代码由Python语言完成,...
  • DBSCAN聚类算法Python实现

    万次阅读 多人点赞 2019-03-30 20:26:54
    DBSCAN是一种基于密度的聚类算法,这类密度聚类算法一般假定类别可以通过样本分布的紧密程度决定。同一类别的样本,他们之间的紧密相连的,也就是说,在该类别任意样本周围不远处一定有同类别的样本存在。 通过将...
  • FP-Growth算法python实现(完整代码)

    热门讨论 2015-07-04 00:40:44
    包含两个文件,一个是刚构造好FP-tree的代码,另一个是FP-Growth算法python实现的完全代码。更多的介绍请见博客:http://blog.csdn.net/bone_ace/article/details/46746727
  • 分水岭算法python实现及解析

    千次阅读 2022-03-29 21:25:55
    1 算法简介 分水岭算法的原理很容易查到,就是往山谷中注水,把不同湖水接触的位置称作分水岭,这么做的结果有两个: 1.得到整个区域的分界线 2.把整个区域编号 这是一种很容易过分割的算法,需要一些预处理手段和...
  • 在GitHub上找到一个开源的项目实现了数学建模中常用的算法包括: 差分进化算法 遗传算法 粒子群算法 模拟退火算法 蚁群算法 免疫优化算法 人工鱼群算法 项目链接: https://github.com/zhangxiao123qqq/scikit-opt...
  • python_分水岭算法

    千次阅读 2021-11-13 11:31:22
    100) # 分水岭算法分割 markers = cv2.watershed(image, markers=markers) # 标签图像将会被修改,边界区域的标记将变为 -1 # src[markers == -1] = [0, 0, 255] # 红色# 获得到的边界值为-1 min_val, max_val, min_...
  • Python中hash算法

    千次阅读 2022-01-22 12:19:12
    文章目录简介概念特点hash有哪些算法碰撞加盐防碰撞加密hashlib主要方法特有方法使用方法加盐crypt主要方法使用说明应用密码加密应用一致性校验 简介 概念 散列算法(Hash Algorithm),又称哈希算法,杂凑算法,是...
  • 模拟退火算法python(含例程代码与详解)

    千次阅读 多人点赞 2020-10-29 17:48:02
    模拟退火算法详解
  • 全面解析Kmeans聚类算法Python

    千次阅读 2022-04-21 10:16:29
    Clustering (聚类) 是常见的unsupervised learning (无监督学习)方法,简单地说就是把相似的数据...聚类算法可以大致分为传统聚类算法以及深度聚类算法: 传统聚类算法主要是根据原特征+基于划分/密度/层次等方法。
  • 粒子群算法python(含例程代码与详解)

    万次阅读 多人点赞 2020-10-07 09:19:35
    1.粒子群算法简介 粒子群算法的思想源于对鸟类捕食行为的研究,模拟鸟集群飞行觅食的行为,鸟之间通过集体的协作使群体达到最优目的。 设想这样的一个场景,一群鸟在随机的搜索食物,在某块区域里有一块食物, 2....
  • 基于python的MUSIC算法

    千次阅读 2021-12-11 11:16:40
    基于python的MUSIC算法
  • Python A*算法的简单实现

    千次阅读 2021-12-11 16:12:56
    这次正好花了几天时间学习了一下Python,便拿这个算法做了一下练习。这篇文章也会对其思路做一个简单介绍。 文章中的源码可以在 GitHub - anguangzhihen/PythonTest 中的AStarTest.py找到。 算法思路 A*算法...
  • python写的一个k-means聚类算法的实现,测试数据在压缩包的data.txt中,结果通过图示的方法进行直观展示。
  • 特征选择算法之Relief算法python实现

    千次阅读 热门讨论 2019-01-16 17:41:16
    Relief算法python实现Relief算法简介原理伪算法Relief算法python实现代码 Relief算法简介 待补充 原理 待补充 伪算法 待补充 Relief算法python实现 代码 去博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示...
  • 优化算法笔记|灰狼算法理解及Python实现

    万次阅读 多人点赞 2021-01-02 14:58:38
    灰狼优化算法的理解和应用一、背景介绍二、算法原理三、构建算法数学模型四、Python实现GWO 一、背景介绍 灰狼优化算法(Grey Wolf Optimizer,GWO)由澳大利亚格里菲斯大学学者 Mirjalili 等人于2014年提出来的一种...
  • python实现贪心算法

    千次阅读 2021-03-24 10:12:20
    python贪心策略
  • DTW算法Python实现

    万次阅读 2019-03-09 19:02:00
    DTW算法可以用来衡量两个时间序列的相似性,而且两个时间序列的长度可以不必相等。 DTW算法原理 如图1所示,图中矩阵$dij$表示时间序列$A$时刻$i$和时间序列$B$时刻$j$的距离,DTW算法就是要从$(1,1)$到$(m,n)$...
  • python算法之迭代算法

    千次阅读 2020-01-26 21:24:55
    迭代算法基础 确认迭代变量 在可以使用迭代算法解决的值中至少存在一个迭代变量。可以直接或者间接的用旧值推出新值。 建立迭代关系式 迭代关系式是指如何从变量的前一个值推出下一个值的公式或者关系。 对迭代过程...
  • Python算法系列-哈希算法

    千次阅读 多人点赞 2020-04-12 23:11:10
    哈希算法一、常见数据查找算法简介二、什么是哈希三、实例:两个数字的和1.问题描述2.双指针办法解决3.哈希算法求解四、总结 哈希算法又称散列函数算法,是一种查找算法。就是把一些复杂的数据通过某种映射关系。...
  • python线性回归算法

    千次阅读 2021-12-24 11:19:47
    1. 线性回归算法 2. 在Python中实现线性回归 那我们如何在Python中实现呢? 利⽤Python强⼤的数据分析⼯具来处理数据。 Numpy提供了数组功能,以及对数据进⾏快速处理的函数。Numpy还是很多⾼级扩展库的依赖,⽐如...
  • 原标题:推荐 10 本程序员必读的算法书 我们为你总结了十本各具特色的算法书,学习课程的同时,阅读这些书籍,快速前进,离你的理想目标更近一步!1.《算法导论》 Thomas H. Corman 这是最著名的算法书之一,但要...
  • 今天跟大家总结的Python学习教程关于Python算法的实现,上次催我更算法的伙伴可以粗来了!1、选择排序选择排序是一种简单直观的排序算法。它的原理是这样:首先在未排序序列中找到最小(大)元素,存放到排序序列的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 799,864
精华内容 319,945
关键字:

内容推荐算法python