精华内容
下载资源
问答
  • https://jimmee.iteye.com/blog/1985774时间复杂度n^2表示n平方,选择排序有时叫做直接选择排序或简单选择排序排序方法平均时间最好时间最坏时间桶排序(不稳定)O(n)O(n)O(n)基数排序(稳定)O(n)O(n)O(n)归并排序...

    https://jimmee.iteye.com/blog/1985774

    时间复杂度

    n^2表示n的平方,选择排序有时叫做直接选择排序或简单选择排序

    排序方法

    平均时间

    最好时间

    最坏时间

    桶排序(不稳定)

    O(n)

    O(n)

    O(n)

    基数排序(稳定)

    O(n)

    O(n)

    O(n)

    归并排序(稳定)

    O(nlogn)

    O(nlogn)

    O(nlogn)

    快速排序(不稳定)

    O(nlogn)

    O(nlogn)

    O(n^2)

    堆排序(不稳定)

    O(nlogn)

    O(nlogn)

    O(nlogn)

    希尔排序(不稳定)

    O(n^1.25)

    冒泡排序(稳定)

    O(n^2)

    O(n)

    O(n^2)

    选择排序(不稳定)

    O(n^2)

    O(n^2)

    O(n^2)

    直接插入排序(稳定)

    O(n^2)

    O(n)

    O(n^2)

    O(n)这样的标志叫做渐近时间复杂度,是个近似值.各种渐近时间复杂度由小到大的顺序如下

    O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

    一般时间复杂度到了2^n(指数阶)及更大的时间复杂度,这样的算法我们基本上不会用了,太不实用了.比如递归实现的汉诺塔问题算法就是O(2^n).

    平方阶(n^2)的算法是勉强能用,而nlogn及更小的时间复杂度算法那就是非常高效的算法了啊.

    空间复杂度

    冒泡排序,简单选择排序,堆排序,直接插入排序,希尔排序的空间复杂度为O(1),因为需要一个临时变量来交换元素位置,(另外遍历序列时自然少不了用一个变量来做索引)

    快速排序空间复杂度为logn(因为递归调用了) ,归并排序空间复杂是O(n),需要一个大小为n的临时数组.

    基数排序的空间复杂是O(n),桶排序的空间复杂度不确定

    最快的排序算法是桶排序

    所有排序算法中最快的应该是桶排序(很多人误以为是快速排序,实际上不是.不过实际应用中快速排序用的多)但桶排序一般用的不多,因为有几个比较大的缺陷.

    1.待排序的元素不能是负数,小数.

    2.空间复杂度不确定,要看待排序元素中最大值是多少.

    所需要的辅助数组大小即为最大元素的值.

    展开全文
  • 堆基本概念堆排序是一个很重要的排序算法,它是高效率的排序算法复杂度是O(nlogn),堆排序不仅是面试进场考重点,而且在很多实践中算法会用到它,比如经典TopK算法、小顶堆用于实现优先级队列。堆排序是利用...

    原创文章出自公众号:「码农富哥」,欢迎转载和关注,如转载请注明出处!

    堆基本概念

    堆排序是一个很重要的排序算法,它是高效率的排序算法,复杂度是O(nlogn),堆排序不仅是面试进场考的重点,而且在很多实践中的算法会用到它,比如经典的TopK算法、小顶堆用于实现优先级队列。

    堆排序是利用堆这种数据结构所设计的一种排序算法。堆实际上是一个完全二叉树结构。

    问:那么什么是完全二叉树呢?

    答:假设一个二叉树的深度为h,除第 h 层外,其它各层 (1~h-1) 的结点数都达到最大个数,第 h 层所有的结点都连续集中在最左边,这就是完全二叉树。

    我们知道堆是一个完全二叉树了,那么堆又分两种堆:大顶堆 和 小顶堆

    它们符合一个重要的性质:

    小顶堆满足: Key[i] <= key[2i+1] && Key[i] <= key[2i+2]

    大顶堆满足: Key[i] >= Key[2i+1] && key >= key[2i+2]

    怎么理解呢,其实很简单,顾名思义,大顶堆最大的元素在跟节点,堆的性质决定了大顶堆中节点一定大于等于其子节点,反之,小顶堆的最小元素在根节点。我们来看看大顶堆和小顶堆的示意图:

    堆排序基本思想及步骤

    堆排序有以下几个核心的步骤:

    将待排序的数组初始化为大顶堆,该过程即建堆。

    将堆顶元素与最后一个元素进行交换,除去最后一个元素外可以组建为一个新的大顶堆。

    由于第二部堆顶元素跟最后一个元素交换后,新建立的堆不是大顶堆,需要重新建立大顶堆。重复上面的处理流程,直到堆中仅剩下一个元素。

    假设我们有一个待排序的数组 arr = [4, 6, 7, 2, 9, 8, 3, 5], 我们把这个数组构造成为一个二叉树,如下图:

    问:此时我们需要把这个完全二叉树构造成一个大顶堆,怎么构造呢?

    答:一个很好的方法是遍历二叉树的非叶子节点自下往上的构造大顶堆,针对每个非叶子节点,都跟它的左右子节点比较,把最大的值换到这个子树的父节点。

    问:为什么要从非叶子节点开始,而不是从最后一个节点开始?

    答:因为叶子节点下面没有子节点了,就没必要操作了。

    问:为什么要从下往上而不是从上往下遍历非叶子节点?

    答:我们从下面开始遍历调整每个节点成为它左右节点的最大值,那么一直往上的话,最后根节点一定是最大的值;但是如果我们从上往下,上面满足了大顶堆,下面不满足,调整后,上面可能又不满足了,所以从下往上是最好的方案。

    那么我们构造的大顶堆的代码就很明显了:

    # 构造大顶堆,从非叶子节点开始倒序遍历,因此是l//2 -1 就是最后一个非叶子节点

    l = len(arr)

    for i in range(l//2-1, -1, -1):

    build_heap()

    # 遍历针对每个非叶子节点构造大顶堆

    看我们的例子,非叶子节点有2, 8, 6, 4, 我们从最后一个非叶子节点,也就是5开始遍历构造大顶堆,2 跟 5 比较,5比较大,所以把 arr[3]和arr[7]从数组中交换一下位置,那么就完成第一个非叶子节点的置换。下面的节点继续交换

    此时9跟4交换后,4这个节点下面的树就不是不符合大顶堆了,所以要针对4这个节点跟它的左右节点再次比较,置换成较大的值,4跟左右子节点比较后,应该跟6交换位置。

    那么至此,整个二叉树就是一个完完整整的大顶堆了,每个节点都不小于左右子节点。

    此时我们把堆的跟节点,即数组最大值9跟数组最后一个元素2交换位置,那么9就是排好序的放在了数组最后一个位置

    2到了跟节点后,新的堆不满足大顶堆,我们需要重复上面的步骤,重新构造大顶堆,然后把大顶堆根节点放到二叉树后面作为排好序的数组放好。就这样利用大顶堆一个一个的数字排好序。

    值得注意的一个地方是,上面我们把9和2交换位置后,2处于二叉树根节点,2需要跟右子树8交换位置,交换完位置后,右子树需要重新递归调整大顶堆,但是左子树6这边,已经是满足大顶堆属性,因为不需要再操作。

    我们再看看堆排序的一个直观的动图吧:

    代码实现:

    class Solution(object):

    def heap_sort(self, nums):

    i, l = 0, len(nums)

    self.nums = nums

    # 构造大顶堆,从非叶子节点开始倒序遍历,因此是l//2 -1 就是最后一个非叶子节点

    for i in range(l//2-1, -1, -1):

    self.build_heap(i, l-1)

    # 上面的循环完成了大顶堆的构造,那么就开始把根节点跟末尾节点交换,然后重新调整大顶堆

    for j in range(l-1, -1, -1):

    nums[0], nums[j] = nums[j], nums[0]

    self.build_heap(0, j-1)

    return nums

    def build_heap(self, i, l):

    """构建大顶堆"""

    nums = self.nums

    left, right = 2*i+1, 2*i+2 ## 左右子节点的下标

    large_index = i

    if left <= l and nums[i] < nums[left]:

    large_index = left

    if right <= l and nums[left] < nums[right]:

    large_index = right

    # 通过上面跟左右节点比较后,得出三个元素之间较大的下标,如果较大下表不是父节点的下标,说明交换后需要重新调整大顶堆

    if large_index != i:

    nums[i], nums[large_index] = nums[large_index], nums[i]

    self.build_heap(large_index, l)

    堆排序复杂度

    时间复杂度, 包括两个方面:

    初始化建堆过程时间:O(n)

    更改堆元素后重建堆时间:O(nlogn),循环 n -1 次,每次都是从根节点往下循环查找,所以每一次时间是 logn,总时间:logn(n-1) = nlogn - logn ,所以复杂度是 O(nlogn)

    时间复杂度:O(nlogn)

    空间复杂度: 因为堆排序是就地排序,空间复杂度为常数:O(1)

    堆排序的应用:TopK算法

    面试中经常考的一个面试题就是,如果在海量数据中找出最大的100个数字,看到这个问题,可能大家首先会想到的是使用高效排序算法,比如快排,对这些数据排序,时间复杂度是O(nlogn),然后取出最大的100个数字。但是如果数据量很大,一个机器的内存不足以一次过读取这么多数据,就不能使用这个方法了。

    不使用分布式机器计算,使用一个机器也能找出TopK的经典算法就是使用堆排序了,具体方法是:

    维护一个大小为 K 的小顶堆,依次将数据放入堆中,当堆的大小满了的时候,只需要将堆顶元素与下一个数比较:

    如果小于堆顶元素,则直接忽略,比较下一个元素;

    如果大于堆顶元素,则将当前的堆顶元素抛弃,并将该元素插入堆中。遍历完全部数据,Top K 的元素也自然都在堆里面了。

    整个操作中,遍历数组需要O(n)的时间复杂度,每次调整小顶堆的时间复杂度是O(logK),加起来就是 O(nlogK) 的复杂度,如果 K 远小于 n 的话, O(nlogK) 其实就接近于 O(n) 了,甚至会更快,因此也是十分高效的。

    总结

    堆排序有以下几个核心的步骤:

    将待排序的数组初始化为大顶堆,该过程即建堆。

    将堆顶元素与最后一个元素进行交换,除去最后一个元素外可以组建为一个新的大顶堆。

    由于第二部堆顶元素跟最后一个元素交换后,新建立的堆不是大顶堆,需要重新建立大顶堆。重复上面的处理流程,直到堆中仅剩下一个元素。

    最后

    文章如果对你有收获,可以收藏转发,这也是对我写作的肯定!另外可以关注我公众号「码农富哥」 ,我会持续输出Python,服务端架构,计算机基础(MySQL, Linux,TCP/IP)的 原创 文章

    展开全文
  • python实现排序算法(一)排序算法介绍所谓排序,就是使一串记录,按照其中某个或某些关键字大小,递增或递减排列起来操作。排序算法,就是如何使得记录按照要求排列方法。排序算法在很多领域得到相当地重视...

    python实现排序算法(一)

    排序算法介绍

    所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。排序算法,就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。

    在学习算法的时候,需要学会理解算法是如何实现的,掌握其算法的原理,以及如何判断算法的优越性。

    冒泡排序

    冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    算法原理

    比较相邻的元素,如果第一个比第二个大,就交换他们;

    对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;

    针对所有的元素重复以上步骤,除了最后一个;

    重复步骤 1~3,直到排序完成。

    复杂度分析

    最坏复杂度: 时间复杂度为 O(n^2)

    最好复杂度:时间复杂度为 O(n)

    平均复杂度: 时间复杂度为 O(n^2)

    实例应用

    请在给定 bubble_sort 参考代码的基础上,完成以下目标。

    目标:给定列表进行冒泡排序

    示例:sequence=[12, 27, 46, 16, 25, 37, 22, 29, 15, 47, 48, 34]

    算法实现

    def bubble_sort(sequence):

    #遍历的趟数,n个元素,遍历n-1趟

    for i in range(1,len(sequence)):

    #从头遍历列表

    for j in range(0,len(sequence)-1):

    #遍历过程中,若前者数值大于后者,则交换

    if sequence[j]>sequence[j+1]:

    # 注意,python中列表交换,不需要中间变量,可直接交换

    sequence[j],sequence[j+1]=sequence[j+1],sequence[j]

    #返回处理完成后的列表

    return sequence

    if __name__ == '__main__':

    sequence = [12, 27, 46, 16, 25, 37, 22, 29, 15, 47, 48, 34]

    print(sequence)

    print(bubble_sort(sequence))

    处理前后如下所示

    选择排序

    选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n^2) 的时间复杂度。所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

    算法原理

    首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置;

    再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾;

    重复第二步,直到所有元素均排序完毕。

    复杂度分析

    最坏复杂度: 时间复杂度为 O(n^2)

    最好复杂度:时间复杂度为 O(n^2)

    平均复杂度: 时间复杂度为 O(n^2)

    算法实现

    def select_sort(sequence):

    #排序的趟数

    for i in range(len(sequence)-1):

    # 记录最小数的索引

    minIndex = i

    #从当前位置往后遍历寻找比当前值还小的最小值

    for j in range(i + 1, len(sequence)):

    #如果小于最小值,覆盖最小值索引为当前值索引

    if sequence[j] < sequence[minIndex]:

    minIndex = j

    # 将该数放到已排序序列的未部

    sequence[minIndex], sequence[i] = sequence[i], sequence[minIndex]

    return sequence

    if __name__ == '__main__':

    sequence = [12, 27, 46, 16, 25, 37, 22, 29, 15, 47, 48, 34]

    print(sequence)

    print(select_sort(sequence))

    插入排序

    插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

    算法原理

    从第一个元素开始,该元素可以认为已经被排序;

    取出下一个元素,在已经排序的元素序列中从后向前扫描;

    如果该元素(已排序)大于新元素,将该元素移到下一位置;

    重复步骤 3,直到找到已排序的元素小于或者等于新元素的位置;

    将新元素插入到该位置后;

    重复步骤 2-5。

    复杂度分析

    最坏复杂度: 时间复杂度为 O(n^2)

    最好复杂度:时间复杂度为 O(n^2)

    平均复杂度: 时间复杂度为 O(n^2)

    算法实现

    def insertion_sort(sequence):

    #趟数

    for index in range(1,len(sequence)):

    """ 详情请看算法原理 """

    while(index>0 and sequence[index-1]>sequence[index]):

    sequence[index],sequence[index-1]=sequence[index-1],sequence[index]

    index=index-1

    return sequence

    if __name__ == '__main__':

    sequence = [12, 27, 46, 16, 25, 37, 22, 29, 15, 47, 48, 34]

    print(sequence)

    print(insertion_sort(sequence))

    展开全文
  • 本文将从时间复杂度的概念出发,结合实际代码示例分析算法的时间复杂度。渐进时间复杂度时间复杂度是算法运算所消耗的时间,因为不同大小的输入数据,算法处理所要消耗的时间是不同的,因此评估一个算运行时间是比较...

    在实现算法的时候,通常会从两方面考虑算法的复杂度,即时间复杂度和空间复杂度。顾名思义,时间复杂度用于度量算法的计算工作量空间复杂度用于度量算法占用的内存空间

    本文将从时间复杂度的概念出发,结合实际代码示例分析算法的时间复杂度

    渐进时间复杂度

    时间复杂度是算法运算所消耗的时间,因为不同大小的输入数据,算法处理所要消耗的时间是不同的,因此评估一个算运行时间是比较困难的,所以通常关注的是时间频度,即算法运行计算操作的次数,记为T(n),其中n称为问题的规模。

    同样,因为n是一个变量,n发生变化时,时间频度T(n) 也在发生变化,我们称时间复杂度的极限情形称为算法的渐近时间复杂度,记为O(n),不包含函数的低阶和首项系数。

    我们以如下 例子来解释一下:

    b18d760237ea46ff99a7143e8235a9b1.png

    如上例子中,我们根据代码上执行的平均时间假设,计算 run_time(n) 函数的时间复杂度,如下:

    43ee4711a64981423a2f2a1dce44a07a.png

    上述时间复杂度计算公式T(n) ,是我们对函数 run_time(n) 进行的时间复杂度的估算。当n 值非常大的时候,T(n)函数中常数项 time0 以及n的系数 (time1+time2+time3+time4) 对n的影响也可以忽略不计了,因此这里函数run_time(n) 的时间复杂度我们可以表示为 O(n)

    因为我们计算的是极限状态下(如,n非常大)的时间复杂度,因此其中存在以下两种特性:

    • 低阶项相对于高阶项产生的影响很小,可以忽略不计。
    • 最高项系数对最高项的影响也很小,可以忽略不计。

    根据上述两种特性,时间复杂度的计算方法:

    1.只取最高阶项,去掉低阶项。

    2.去掉最高项的系数。

    3.针对常数阶,取时间复杂度为O(1)。


    我们通过下面例子理解一下常见的时间复杂度,如下:

    时间复杂度:常数阶 O(1)

    4d90302cf829d54ecd41c830914710eb.png

    时间复杂度:线性阶 O(n)

    014cb0982738b09391ab06524e6250c4.png

    时间复杂度:线性阶 O(n)

    a70f3d58f44ecc063044f5ae96ed8578.png

    时间复杂度:平方阶 O(n^2)

    b37e5f0266825c53ff040b2e214f34f5.png

    时间复杂度:平方阶 O(n^2)

    62180c55105069b611407cac1ccbe4a9.png

    时间复杂度:平方阶 O(n^2)

    76cf5d13210e1363593a6628f7cef1f9.png

    时间复杂度:立方阶 O(n^3)

    b430d03bc8ba177c870774eb48999bce.png

    时间复杂度:对数阶 O(logn)

    8ab34b69014156eeb4290da9284e33bb.png

    随着问题规模n的不断增大,上述时间复杂度不断增大,算法的执行效率越低,时间复杂度排序如下:

    b9c0754389c7fa244ea9dff316fbea76.png

    练习一下

    如下count_sort 函数实现了计数排序,列表中的数范围都在0到100之间,列表长度大约为100万。

    07ee7103c3b71c849bd9be6e885cddb9.png

    如上count_sort 函数的 空间复杂度为 O(n),公式如下:

    a1a980a5798b612acaf8f56d8a40a590.png
    展开全文
  • 本文将从时间复杂度的概念出发,结合实际代码示例分析算法的时间复杂度。渐进时间复杂度时间复杂度是算法运算所消耗的时间,因为不同大小的输入数据,算法处理所要消耗的时间是不同的,因此评估一个算运行时间是比较...
  • 排序算法在算法界是一个怎么样的存在?就好像在学术界中数学的地位,说直接用好像用不上,可是不会做起事情来总会捉襟见肘,左支右绌。...2.排序算法的平均复杂度是有下限的,为nlog(n)。所以大家不要再想着...
  • 本文将从时间复杂度的概念出发,结合实际代码示例分析算法的时间复杂度。渐进时间复杂度时间复杂度是算法运算所消耗的时间,因为不同大小的输入数据,算法处理所要消耗的时间是不同的,因此评估一个算运行时间是比较...
  • 所以相同元素前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。(2)选择排序选择排序是给每个位置选择当前元素最小,比如给第一个位置选择最小。……例子说明好多了。序列58 5 29,我们知道第一遍选择第1...
  • 一:冒泡排序时间复杂度:O(n2)原理:(1):相邻元素互相比较 如果第一个比第二个大 就交换两者位置(2):对每一对邻居做比较 从头走到尾 即走了一趟 最后一位元素即为最大元素(3):针对所有元素重复以上步骤 除了...
  • 排序算法的时间复杂度 排序算法 时间复杂度 稳定性 冒泡排序 O(n2) 稳定 插入排序 O(n2) 稳定 归并排序 O(N*logN) 稳定 选择排序 O(n2) 不稳定 快速排序 O(N*logN) 不稳定 堆排序 O(N*logN) 不...
  • 我们来算一下最坏情况下三种算法各需要多少次比较和赋值操作。选择排序在第i次选择时赋值和...插入排序在第i次寻找插入位置时需要最多i-1次比较(从后往前找到第一个比待插入数小数,最坏情况发生在这个数是所...
  • 这几天笔试了好几次了,连续碰到一个关于常见排序算法稳定性判别的问题,往往还是多选,对于我以及和我一样拿不准的...首先,排序算法的稳定性大家应该都知道,通俗地讲就是能保证排序前2个相等的数其在序列的前后...
  • 排序算法 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定排序 冒泡排序 O(n^2) O(n^2) O(1) 稳定 鸡尾酒排序 O(n^2) O(n^2) O(1) 稳定 快速排序 O(nlogn) O(n^2) O(logn) 不稳定 堆排序 O(nlogn) O(nlogn...
  • 1、冒泡排序核心算法:在数组x[n]中,从第一个数开始,拿x[i]和后面数x[i+1]进行比较,如果x[i]比后面大,就交换两个数位置,这样遍历一遍数组后,把最大数据排在了最后面,之后继续循环排剩下n-1个数,...
  • 递归形式递归形式是算法中常用到一种构造思路。递归允许函数或过程对自身进行调用,是对算法中重复过程高度概括,从本质层面进行刻画,避免算法书写中过多嵌套循环和分支语法。因此,是对算法结构很大简化。...
  • Python算法和数据结构(二)——各大排序算法的时空复杂度比较一、各大排序算法的时空复杂度表格二、对一些问题的注释1、冒泡排序2、选择排序3、插入排序4、快速排序5、堆排序 一、各大排序算法的时空复杂度表格 ...
  • 算法(Algorithm)概念:一个计算过程,解决问题方法 递归两大特点: 1、自己调用自己 2、有穷性(python默认只能递归999次)自己修改递归深度:sys.setrecursionlimit(100000) def func1(x): if x>0:...
  • 近期很多童鞋在讨论大厂面试算法题,有部分同学表示一脸懵逼,不知从何下手,还有一一部分同学写冒泡排序算法是直接从网上复制下来冒泡排序,大多数都没有考虑时间复杂度,说白了只是实现了冒泡流程,严格来...
  • 2.由于最优时间复杂度和平均复杂度只能解决部分情况,因此通常以最坏时间复杂度为评判标准。 3.时间复杂度的基本计算原则: 常数项视为常数 顺序结构:时间复杂度按加法计算 循环结构:时间复杂度按乘法计算 ...
  • 近期很多童鞋在讨论大厂面试算法题,有部分同学表示一脸懵逼,不知从何下手,还有一一部分同学写冒泡排序算法是直接从网上复制下来冒泡排序,大多数都没有考虑时间复杂度,说白了只是实现了冒泡流程,严格来...
  • 其实一直对稳定性不是很理解,今天研究python实现排序算法的时候突然有了新的体会,一定要记录下来 稳定性: 稳定性指的是 当排序碰到两个相等数的时候,他们的顺序会不会发生交换。其实对于一个整数数列的排序,...
  • 文章目录快速排序归并排序 快速排序 快速排序排序时主要进行两部操作。 随机选取一个基准值,随机值可以选择第一个值,但建议从中间选择减少遇到最坏状况概率(随机值选取到最大值或者最小值时最坏状况) 将...
  • 目录一、算法时间复杂度的应用二、如何计算算法的时间复杂度举例说明三、常用的时间复杂度时间复杂度排序四、代码说明 一、算法时间复杂度的应用 在实际应用中,会根据要解决的问题写出几个相应的解决办法,但是我们...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域较简单的排序算法。它重复地走访过要排序数列,一次比较两个元素,如果他们顺序错误就把他们交换过来。走访数列工作是重复地进行直到没有再需要交换,也就是说...
  • 冒泡排序的基本思想冒泡排序的基本思想是:每次比较两个相邻元素,如果他们顺序错误就把他们交换过来。简化版排序不仅仅有上一节所遗留问题,更要命是:它非常浪费空间!例如需要排序范围是0~...
  • 在刷leetcode一道要求时间复杂度的题目,用了sort排序,发现时间复杂度还可以。#python的排序详解排序,在编程中经常遇到的算法,我也在几篇文章中介绍了一些关于排序的算法。有高级语言内置了一些排序函数。本文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,632
精华内容 652
关键字:

python排序算法的时间复杂度

python 订阅