精华内容
下载资源
问答
  • 一、冒泡排序简介冒泡排序(Bubble Sort)是一种常见的排序算法,相对来说比较简单。冒泡排序重复地走访需要排序的元素列表,依次比较两个相邻的元素,如果顺序(如从大到小或从小到大)错误就交换它们的位置。重复地...

    一、冒泡排序简介

    冒泡排序(Bubble Sort)是一种常见的排序算法,相对来说比较简单。

    冒泡排序重复地走访需要排序的元素列表,依次比较两个相邻的元素,如果顺序(如从大到小或从小到大)错误就交换它们的位置。重复地进行直到没有相邻的元素需要交换,则元素列表排序完成。

    在冒泡排序中,值最大(或最小)的元素会通过交换慢慢“浮”到元素列表的“顶端”。就像“冒泡”一样,所以被称为冒泡排序。

    二、冒泡排序原理

    冒泡排序的原理如下:

    1. 比较相邻的两个元素。如果第一个比第二个大则交换他们的位置(升序排列,降序则反过来)。

    2. 从列表的开始一直到结尾,依次对每一对相邻元素都进行比较。这样,值最大的元素就通过交换“冒泡”到了列表的结尾,完成第一轮“冒泡”。

    3. 重复上一步,继续从列表开头依次对相邻元素进行比较。已经“冒泡”出来的元素不用比较(一直比较到结尾也可以,已经“冒泡”到后面的元素即使比较也不需要交换,不比较可以减少步骤)。

    4. 继续从列表开始进行比较,每轮比较会有一个元素“冒泡”成功。每轮需要比较的元素个数会递减,一直到只剩一个元素没有“冒泡”时(没有任何一对元素需要比较),则列表排序完成。

    以列表 [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21] 进行升序排列为例。列表的初始状态如下图。

    2c740f520f529824f5a2f0738d9252d0.png

    要进行升序排列,则大的元素要依次“冒泡”到列表的结尾。

    1. 从列表的开头,比较相邻的两个元素,如果第一个值比第二个值大则交换。10小于17,不需要交换。

    ab3240133afcc73728ae3855bca3ecb4.png

    2. 向列表的结尾方向“走访”,比较第二组相邻的元素(第二个和第三个),如果不是从小到大则交换。17小于50,不需要交换。

    485e1d091c995599571a3fb79fbfdbfb.png

    3. 继续“走访”,比较第三组相邻的元素,如果不是从小到大则交换。50大于7,所以需要交换。

    c04b3830c6deca3f8b98f4157f7b0272.png

    4. 对顺序错误的元素进行位置交换。交换50和7的位置。

    53312e5aeaaaf95f23b44bcf4fc18013.png

    5. 一直“走访”到结尾,第一轮“冒泡”结束后,值最大的元素“冒泡”到了列表的结尾。50“冒泡”到了列表结尾。

    7ac8e0cc365e30b02c892cdd294bda5e.png

    在下一轮“冒泡”中,不需要再将50进行比较,需要比较的元素个数减1。

    6. 从列表开头,重复下一轮“冒泡”,每进行一轮“冒泡”,需要比较的元素都少一个,直到没有元素对需要比较时,整个列表排序完成。排序结果如下图。

    eb496774f901dbe5901e065a9b976b8d.png

    三、Python实现冒泡排序

    # coding=utf-8

    def bubble_sort(array):

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

    for j in range(0, len(array)-i):

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

    array[j], array[j+1] = array[j+1], array[j]

    return array

    if __name__ == '__main__':

    array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]

    print(bubble_sort(array))

    运行结果:

    [5, 7, 10, 15, 17, 21, 24, 27, 30, 36, 45, 50]

    代码中,i 表示第几轮“冒泡”,j 表示“走访”到的元素索引。每一轮“冒泡”中,j 需要从列表开头“走访”到 len(array) – i 的位置。

    四、冒泡排序的时间复杂度和稳定性

    1. 时间复杂度

    在没有特殊说明时,一般都是计算最坏时间复杂度。

    在冒泡排序中,最坏的情况是元素列表的初始状态是完全逆序排列的,需要进行 n-1 轮“冒泡”,每一轮“冒泡”需要进行 n-i 次比较和交换操作。i 的平均值为 n/2 ,时间复杂度为 T(n)=n(n-1)/2 ,再乘每次操作的步骤数(常数,不影响大O记法),所以冒泡排序的时间复杂度为 O(n^2) 。

    2. 稳定性

    排序算法的稳定性指,当元素列表中有相等的元素时,相等元素的相对次序是否固定不变,如果相对次序固定不变,则排序算法是稳定的,反之。

    在冒泡排序中,每次比较两个元素,当元素的大小顺序错误时才会进行交换,如果元素列表中有两个相等的元素,它们最终肯定会相邻在一起,但对它们比较时不会进行交换,相对次序是保持不变的。所以冒泡排序是一种稳定的排序算法。

    冒泡排序优化:将时间复杂度降为O(n)

    def bublle_sort(alist):

    """冒泡排序"""

    n = len(alist)

    for j in range(n-1):

    count = 0

    for i in range(0, n-1-j):

    #从头走到为

    if alist[i]>alist[i+1]:

    alist[i],alist[i+1] = alist[i+1],alist[i]

    count +=1

    if 0 == count:

    break

    if __name__ == "__main__":

    li = [54,25,93,17,77,31,44,55,20,10]

    print(li)

    bublle_sort(li)

    print(li)

    如有失效,请留言告知丨转载请注明原文链接:Python冒泡排序及优化

    展开全文
  • Python冒泡排序及优化、选择排序、插入排序及优化 1. 冒泡排序 def bubble_sort(alist): '''冒泡排序''' for i in range(len(alist)-1, 0, -1): # i表示每次遍历需要比较的次数,逐渐减小 for j in range...

    Python冒泡排序及优化、选择排序、插入排序及优化

    1. 冒泡排序

    在这里插入图片描述

    def bubble_sort(alist):
        '''冒泡排序'''
        for i in range(len(alist)-1, 0, -1):   # i表示每次遍历需要比较的次数,逐渐减小
            for j in range(i):
                if alist[j] > alist[j + 1]:
                    alist[j], alist[j + 1] = alist[j + 1], alist[j]
            
    alist = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    bubble_sort(alist)
    print(alist)
    
    [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    
    • 冒泡排序优化

      def bubble_sort2(alist):
          '''冒泡排序优化'''
          for i in range(len(alist)-1, 0, -1):
              count = 0        # 记录交换次数
              for j in range(i):
                  if alist[j] > alist[j + 1]:
                      alist[j], alist[j + 1] = alist[j + 1], alist[j]
                      count += 1
              if count == 0:   # 若某次遍历中无交换,则不用再比较
                  return
              
      alist2 = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
      bubble_sort2(alist2)
      print(alist2)
      
      [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
      

    2. 选择排序

    在这里插入图片描述

    def selection_sort(alist):
        '''选择排序'''
        n = len(alist)
        for i in range(n-1):               # n-1次选择操作
            min_index = i                  # 最小值位置
            for j in range(i + 1, n):      # 从i+1位置到末尾选择出最小数字
                for j in range(i + 1, n):
                    if alist[j] < alist[min_index]:
                        min_index = j
            if min_index != i:             # 若选择出的数字不在正确位置,则进行交换
                alist[i], alist[min_index] = alist[min_index], alist[i]
    
    alist = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    selection_sort(alist)
    print(alist)
    
    [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    

    3. 插入排序

    在这里插入图片描述

    def insert_sort(alist):
        '''插入排序'''
        for i in range(1, len(alist)):   # 从第2个位置,即下标为1的元素开始向前插入
            for j in range(i, 0, -1):    # 从第i个元素开始向前比较,若小于前一个元素,则交换位置(向前插一位)
                if alist[j] < alist[j - 1]:
                    alist[j], alist[j - 1] = alist[j - 1], alist[j]
    
    alist = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
    insert_sort(alist)
    print(alist)
    
    [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    
    • 插入排序优化

      def insert_sort2(alist):
          '''插入排序优化'''
          for i in range(1, len(alist)):
              for j in range(i, 0, -1):
                  if alist[j] < alist[j - 1]:
                      alist[j], alist[j - 1] = alist[j - 1], alist[j]
                  else:       # 当前数字大于等于前一个数字,则不再进行比较
                      break
      
      alist2 = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
      insert_sort(alist2)
      print(alist2)
      
      [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
      

    总结:

    类别 最优时间复杂度 最坏时间复杂度 平均时间复杂度 空间复杂度 稳定性
    冒泡排序 O(n)O(n) O(n2)O(n^2) O(n2)O(n^2) O(1)O(1) 稳定
    选择排序 O(n2)O(n^2) O(n2)O(n^2) O(n2)O(n^2) O(1)O(1) 不稳定
    插入排序 O(n)O(n) O(n2)O(n^2) O(n2)O(n^2) O(1)O(1) 稳定

    图片来源于:

    展开全文
  • 1.冒泡排序(从大到小):交换发生在内部循环稳定的排序冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)冒泡排序优化在于didswap变量 ,通过这个变量的设置,...

    1.冒泡排序(从大到小):交换发生在内部循环

    稳定的排序

    冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)

    冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n)

    #!usr/bin/python

    arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]

    def BubbleSort(list):

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

    didswap = False

    for j in range(len(list)-1-i):

    if list[j]

    list[j],list[j+1]=list[j+1],list[j]

    didswap =True

    if didswap == False:

    return list

    return list

    print (BubbleSort(arr))

    2.选择排序(从大到小):交换发生在外部循环

    不稳定的排序

    平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)

    #!usr/bin/python

    defSelectSort(lists):

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

    max=i

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

    if lists[j]>lists[max]:

    max=j

    lists[max],lists[i]=lists[i],lists[max]

    returnlists

    lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]

    print SelectSort(lists)

    3.插入排序(从大到小排序):

    稳定的排序

    平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)

    #!usr/bin/python

    defInsertSort(lists):for i in range(1,len(lists)):

    key=lists[i]

    j=i-1

    while j>=0 and lists[j]

    lists[j+1]=lists[j]

    j=j-1lists[j+1]=keyreturnlists

    arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5]print InsertSort(arr)

    4.归并排序(从大到小):归并排序的思想就是分而治之

    归并排序是稳定

    平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O(n)

    #!usr/bin/python

    defMerge(left,right):

    i,j=0,0

    result=[]while i=right[j]:

    result.append(left[i])

    i+=1

    else:

    result.append(right[j])

    j+=1result+=left[i:]

    result+=right[j:]returnresultdefMergeSort(lists):if len(lists)<2:returnlists

    div= len(lists)/2left=MergeSort(lists[0:div])

    right=MergeSort(lists[div:])returnMerge(left,right)

    lists= [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6]print MergeSort(lists)

    5.快速排序:(递归调用)

    平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)

    空间复杂度O(lgn)-Olg(n)

    def QuickSort(myList,start,end):

    #判断low是否小于high,如果为false,直接返回

    if start < end:

    i,j = start,end

    #设置基准数

    base = myList[i]

    while i < j:

    #如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现

    while (i < j) and (myList[j] >= base):

    j = j - 1

    #如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等

    myList[i] = myList[j]

    #同样的方式比较前半区

    while (i < j) and (myList[i] <= base):

    i = i + 1

    myList[j] = myList[i]

    #做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base

    myList[i] = base

    #递归前后半区

    QuickSort(myList, start, i - 1)

    QuickSort(myList, j + 1, end)

    return myList

    lists = [49,38,65,97,76,13,27,49]

    print(QuickSort(lists,0,len(lists)-1))

    print (lists)

    7.堆排序(从大到小):第一步最小堆化;第二步建立最小堆;第三步堆排序

    #!user/bin/python

    defAjustHeap(lists,i,size):

    min=i

    left=2*i+1right=2*i+2

    if i < size/2:if right < size and lists[min] >lists[right]:

    min=rightif left < size and lists[min]>lists[left]:

    min=leftif min!=i:

    lists[i],lists[min]=lists[min],lists[i]

    AjustHeap(lists,min,size)defBuildHeap(lists,size):for i in range(0,(size/2))[::-1]:

    AjustHeap(lists,i,size)defHeapSort(lists):

    size=len(lists)

    BuildHeap(lists,size)for i in range(0,size)[::-1]:

    lists[i],lists[0]=lists[0],lists[i]

    AjustHeap(lists,0,i)returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]print HeapSort(arr)

    6.希尔排序(从大到小):(插入排序的一种)

    #!user/bin/python

    defShellSort(lists):

    step=len(lists)/2

    while (step>=1):#step终止循环为1

    for i in range(step,len(lists)):#没一次step对应很多个新列表

    while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序

    lists[i],lists[i-step]=lists[i-step],lists[i]

    i=i-step

    step=step/2

    returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]

    print ShellSort(arr)

    8.计数排序:

    展开全文
  • Python 算法 08 -- 冒泡排序及其优化-1.jpg (93.27 KB, 下载次数: 0)2020-11-6 21:31 上传Python 算法 08 -- 冒泡排序及其优化-2.jpg (56.14 KB, 下载次数: 0)2020-11-6 21:31 上传冒泡排序1、题目假设有一个列表 ...

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-1.jpg (93.27 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-2.jpg (56.14 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    冒泡排序

    1、题目

    假设有一个列表 list = [5,4,3,2,1]

    要求:按从小到大的顺序排序

    2、分析

    ● 冒泡排序的思路

    两两比较,互换位置,每一轮选出最大(小)的数放到列尾

    ● 图解

    ① 第一轮比较

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-3.jpg (40.9 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    第一轮比较

    ② 第二轮比较

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-4.jpg (37.22 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    ③ 第三轮比较

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-5.jpg (31.42 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    ④ 第四轮比较

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-6.jpg (20.95 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    由于每一轮只选出 1 个最大数,当最后一轮只剩 2 个元素时,结束。

    总共需要比较的轮数 = 列数 - 1

    比较的次数 = 列元素的个数 - 1,由于每一轮会排除一个最大(小)数,比较的次数会依次减 1;

    ● Python 代码:

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-7.jpg (47.83 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    ● Python 结果:

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-8.jpg (22.27 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    4、冒泡排序的时间复杂度

    从代码中可以看出一共遍历了

    n-1 + n-2 + … + 2 + 1 = n * (n-1) / 2 = 0.5 * n ^ 2 - 0.5 * n,

    那么时间复杂度是 O (N^2)。

    5、冒泡排序优化

    曾经,Python大星 参加一个面试,面试官突然给我一张纸和笔,让我现场写个冒泡排序。

    so easy,冒泡排序是排序算法中最简单的一个,三下五除二,我就交上答卷。面试官点了点头,示意我的答案正确,但接下来问了我一个问题,就让我回家等消息啦。

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-9.jpg (65.56 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    OS:冒泡排序还能优化???

    例如:无序列表为[2,3,1,4,5]

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-10.jpg (31.42 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    按照之前的冒泡排序的逻辑:该列表需要进行 4 轮排序

    但我们可以观察到:

    ● 在第二轮排序后,整个列表已经达到要求了,后面的循环无意义

    优化点:当第 N 轮 无元素交换位置,则退出循环

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-11.jpg (41.81 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    第一轮排序过程

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-12.jpg (33.01 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    第二轮排序过程

    ● 在第一轮后,我们可以观察到只进行了一次交换,从 3 后的数字已经排好序,故第二轮的比较中,再比较3之后的数字没有意义

    优化点:找出每轮排序的边界

    优化代码:

    a3318c941136e31422f9e0be7c9e8802.gif

    Python 算法 08 -- 冒泡排序及其优化-13.jpg (78.23 KB, 下载次数: 0)

    2020-11-6 21:31 上传

    >>>Python 算法 07 -- 归并排序的奥秘

    展开全文
  • 我对Python相当陌生,我将从...我建议第一个选项是优化冒泡排序,但第二个选项有问题。在维基百科中,这个“允许我们跳过很多元素,结果在最坏的情况下,比较计数提高了大约50%”。所以我的第一个选项的代码看起来...
  • 普通版:def bubble_sort(nums):for i in range(len(nums) - 1):for j in range(len(nums... nums[j + 1]:nums[j], nums[j + 1] = nums[j + 1], nums[j]return nums动态展示一下冒泡排序过程:image.png假设现在有一...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作...
  • #冒泡排序 import random print("冒泡排序") print("随机生成一个列表") list = [] for i in range(8):  num = random.choice(range(100))  list.append(num)  print(list) print("...
  • 一句话说,冒泡排序,就是 两两比较然后最大的后移,最终形成一个有序的数列,从整个流程看就像泡泡往上冒,所以叫做冒泡排序 def bubble_sort(array): if len(array)<2: return array else: n = len(array) ...
  • 冒泡排序大家应该都很熟悉,是一个比较交换排序,时间复杂度是O(n2),之前用过java实现过,现在用python来实现一次,还有其优化 总共用了三种实现方式 话不多说,直接上代码,比较三种的性能------------------ ...
  • #随机数列 a=[5,8,6,3,9,2,1,7] #一、双循环实现冒泡排序 #外环控制回合 for i in range(len(a)-1): #内环实现冒泡处理:每一轮会把最大值冒泡至最后 ...#二、冒泡排序优化,每轮排序后判断是否有
  • 要求:对某一无序列表进行排序,使其按照从小到大排序,不使用python内建函数。 假设给定的列表为: list=[1,2,3,4,5,6,9,8,7] 1、解题思路 看到题目首先脑子里想到的就是前两个数比较大小,如果第一个数大于第二个...
  • 冒泡排序原理 从第一个元素开始(可以从第一个,也可以从最后一个),相邻两两元素进行比较大小,将较大的那个往后移动,否则,两个元素位置...根据冒泡排序的定义,我们可以用python代码实现 def bubble_sort(it...
  • Python和Java冒泡排序 冒泡排序 1)基本概念 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地...
  • 排序算法之简单排序(冒泡、选择、插入)》《排序算法(二)堆排序》1、排序概念这里不再赘述,请参看前面2篇文章2、简单排序冒泡Python实现及优化原理图wKiom1nF8CTRGF7IAACgLGM-eko688.pngwKioL1nF8Cix7...
  • #要点 冒泡排序实现原理 冒泡排序的代码实现及优化 冒泡排序的性能分析 冒泡排序实现原理 冒泡排序是一种相对而言比较简单,也是比较基础的排序算法。
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 快速排序和冒泡排序一样,也是交换排序。不过它是一种不稳定的排序算法(因为关键字的比较和交换是跳跃进行的)。算法思想:快速排序首先选一个轴值(pivot,也有叫基准的),将待排序记录划分成独立的两部分,左侧的...
  • 排序算法之简单排序冒泡、选择、插入)》《排序算法(二)堆排序》1、排序概念这里不再赘述,请参看前面2篇文章2、简单排序冒泡Python实现及优化原理图2.1、基本实现num_list=[ [1,9,8,5,6,7,4,...
  • 快速排序和冒泡排序一样,也是交换排序。不过它是一种不稳定的排序算法(因为关键字的比较和交换是跳跃进行的)。算法思想:快速排序首先选一个轴值(pivot,也有叫基准的),将待排序记录划分成独立的两部分,左侧的...
  • 1、排序概念内部排序和外部排序根据排序过程中,待排序的数据是否全部被放在内存中,分为两大类:内部排序:指的是待排序的数据存放在计算机内存中进行的排序过程;外部排序:指的是排序中要对外...冒泡排序、简...

空空如也

空空如也

1 2 3
收藏数 47
精华内容 18
关键字:

python冒泡排序及优化

python 订阅