精华内容
下载资源
问答
  • 我对Python相当陌生,我将从...我建议第一个选项是优化冒泡排序,但第二个选项有问题。在维基百科中,这个“允许我们跳过很多元素,结果在最坏情况下,比较计数提高了大约50%”。所以我第一个选项代码看起来...

    我对Python相当陌生,我将从排序算法、PEP8和Python的Zen开始我的旅程。我刚在CodeReview上写了一篇帖子。我做了修复,我想问一下Optimizing Bubble Sort : Second option。我建议第一个选项是优化冒泡排序,但第二个选项有问题。在维基百科中,这个“允许我们跳过很多元素,结果在最坏的情况下,比较计数提高了大约50%”。所以我的第一个选项的代码看起来和工作原理一样:def bubble_sort(container):

    """

    Bubble sort with optimization.

    Description

    ----------

    Performance cases:

    Worst : O(n^2)

    Average : O(n^2)

    Best case : O(n)

    Parameters

    ----------

    data_container : Mutable structure with comparable objects and structure

    which has implemented __len__, __getitem__ and __setitem__.

    Returns

    -------

    None

    Examples

    ----------

    >>> bubble_sort([7,1,2,6,4,2,3])

    [1, 2, 2, 3, 4, 6, 7]

    >>> bubble_sort(['a', 'c', 'b'])

    ['a', 'b', 'c']

    """

    # setting up variables

    length = len(container)

    changed = True

    while changed:

    changed = False

    for i in range(length - 1):

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

    container[i], container[i + 1] = container[i + 1], container[i]

    changed = True

    length -= 1

    问题是为了实现第二个优化选项,我必须做些什么改变。另外,到目前为止,我还试着表现得像伪代码一样。我的代码不工作(不分类),看起来像:

    ^{pr2}$

    展开全文
  • 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.计数排序:

    展开全文
  • 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.计数排序:

    展开全文
  • 说到算法中排序,冒泡排序是最简单一种排序算法了,甚至不学数据结构与算法同学都会使用它。但是你有没有想过可以怎么优化?什么是冒泡排序:就像水慢慢烧开,气泡从下往上越来越大那样,第一次循环都把n个...

    这是我通过极客专栏《数据结构与算法之美》学习后的思考,分享一下,希望对你有所帮助。上一篇文章 工作后,为什么还要学习数据结构与算法 的思维导图展现了这个专栏的内容。

    说到算法中的排序,冒泡排序是最简单的一种排序算法了,甚至不学数据结构与算法的同学都会使用它。但是你有没有想过可以怎么优化?

    什么是冒泡排序:就像水慢慢烧开,气泡从下往上越来越大那样,第一次循环都把n个元素中最大的元素移动至最后位置,第二次从前 n-1 个位置中找出最大元素放在最后,重复执行,直到最后结果全部有序。

    最基本的算法实现,无优化版:

    def bubble_sort(collection):

    """无任何优化版"""

    compare_count=0

    length = len(collection)

    for i in range(length-1):

    print(collection) #方便查看数组的排序过程

    for j in range(length-1-i):

    compare_count+=1

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

    tmp = collection[j]

    collection[j] = collection[j+1]

    collection[j+1] = tmp

    print(f"总循环次数{compare_count}")

    return collection

    下面来执行一下,看看执行的过程,及总循环次数:

    print("bubble_sort begin.")

    unsorted = [3,4,2,1,5,6,7,8]

    print("bubble_sort end: ",*bubble_sort(unsorted))

    执行结果如下:

    bubble_sort begin.

    [3, 4, 2, 1, 5, 6, 7, 8]

    [3, 2, 1, 4, 5, 6, 7, 8]

    [2, 1, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    总循环次数28

    bubble_sort end: 1 2 3 4 5 6 7 8

    通过排序的过程可以发现,在第 4 次冒泡时,数据已经有序,因此可以加入判断,如果本次循环没有冒泡(交换),说明数据已经有序,可以直接退出,优化后的代码如下:

    优化一

    def bubble_sort2(collection):

    """如果没有元素交换,说明数据在排序过程中已经有序,直接退出循环"""

    compare_count=0

    length = len(collection)

    for i in range(length-1):

    swapped = False

    print(collection)

    for j in range(length-1-i):

    compare_count+=1

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

    swapped = True

    tmp = collection[j]

    collection[j] = collection[j+1]

    collection[j+1] = tmp

    if not swapped: break # Stop iteration if the collection is sorted.

    print(f"总循环次数{compare_count}")

    return collection

    下面来执行一下,看看执行的过程,及总循环次数:

    print("bubble_sort2 begin.")

    unsorted = [3,4,2,1,5,6,7,8]

    print("bubble_sort2 end:",*bubble_sort2(unsorted))

    执行结果如下:

    bubble_sort2 begin.

    [3, 4, 2, 1, 5, 6, 7, 8]

    [3, 2, 1, 4, 5, 6, 7, 8]

    [2, 1, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    总循环次数22

    bubble_sort2 end: 1 2 3 4 5 6 7 8

    至此,还有没有其他优化方法呢? 聪明的你可能看到了,总循环次数是比较多的,仅比未优化版少了 6 次循环次数。有没有办法减少总循环次数呢?

    观察数据可以发现,数据已经初始有序,可以分为两部分,无序部分 3 4 2 1 和有序部分 5 6 7 8 ,每次循环如果能够发现无序和有序的边界,然后下次冒泡仅对无序部分进行比较和冒泡,可大大减少比较次数(循环次数),从而加快速度。

    问题是,怎么发现这个边界呢? 第一次冒泡的过程中,第一个元素 4 被移动到下标为【3】的位置(python 列表索引从 0 开始),位置 【3】就是有序部分的开始位置。

    第二次冒泡的过程中,第一个元素 3 被移动到下标为【2】的位置(python 列表索引从 0 开始),位置 【2】就是有序部分的开始位置。 ... 可以推断出,一次冒泡的过程中,最后一个被交换的元素下标即为无序和有序的边界,因而下次冒泡,仅对 0 ~ 边界 的元素冒泡即可大大减少循环次数。

    优化二:

    def bubble_sort3(collection):

    """bubble_sort2的基础上再优化。优化思路:在排序的过程中,数据可以从中间分为两段,一段是无序状态,另一段是有序状态。每一次循环的过程中,记录最后一个交换元素的公交车,它便是有序和无序状态的边界下一次仅循环到边界即可,从而减少循环次数,达到优化。"""

    compare_count=0

    length = len(collection)

    last_change_index = 0 #最后一个交换的位置

    border = length-1 #有序和无序的分界线

    for i in range(length-1):

    swapped = False

    print(collection)

    for j in range(0,border):

    compare_count+=1

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

    swapped = True

    collection[j], collection[j+1] = collection[j+1], collection[j]

    last_change_index = j

    if not swapped: break # Stop iteration if the collection is sorted.

    border = last_change_index # 最后一个交换的位置就是边界

    print(f"总循环次数{compare_count}")

    return collection

    下面来执行一下,看看执行的过程,及总循环次数:

    print("bubble_sort3 begin.")

    unsorted = [3,4,2,1,5,6,7,8]

    print("bubble_sort3 end:",*bubble_sort3(unsorted))

    执行结果如下:

    bubble_sort3 begin.

    [3, 4, 2, 1, 5, 6, 7, 8]

    [3, 2, 1, 4, 5, 6, 7, 8]

    [2, 1, 3, 4, 5, 6, 7, 8]

    [1, 2, 3, 4, 5, 6, 7, 8]

    总循环次数10

    bubble_sort3 end: 1 2 3 4 5 6 7 8

    可以看到结果的总循环次数为 10 ,与第二版相比,循环次数减少了一倍。

    冒泡排序算法的性能分析:

    1、执行效率

    最小时间复杂度:很好计算,最好的情况就是数据一开始就是有序的,因此一次冒泡即可完成,时间复杂度为 O(n)

    最大时间复杂度:也很好计算,最坏的情况就是数据一开始就是倒序的,因此进行 n-1 次冒泡即可完成,时间复杂度为 O(n^2)

    平均时间复杂度,严格来说平均时间复杂度就是加权平均期望时间复杂度,分析的时候要结合概率认的知识,对于包含 n 个数据的数组,有 n! 种排序方式,不同的排列方式,冒泡排序的执行时间肯定是不同的,如果要用概率认的方法定量分析平均时间复杂度,涉及的数据推理会很复杂,这里有一种思路,通过有序度和逆序度这两个概念来分析。有序度就是有顺序的元素的个数,比如 3,1 ,2 这三个数据有有序度为1 即 (1,2) 一个,相反,逆序度为 2,即(3,2)(3,1)这两个, 1, 2, 3 这三个数据的有序度为 3:(1,2)(1,3)(2,3),逆序度为 0,完全有序的数据序列的有序度也叫满有序度。 有个公式

    逆序度 = 满有序度 - 有序度

    排序的过程就是增加有序度,减少逆序度,最后达到满有序度,说明排序完成。逆序度也主浊元素的交换次数,最坏情况,初始状态的有序度为 0 ,逆序度为 n*(n-1)/2 , 所以要进行 n*(n-1)/2 次交换操作,最好情况,补充状态完全有序,逆序度为 0 不需要进行交换,这里平均交换次数我们可以取个平均值即 n*(n-1)/4。

    而比较次数肯定比交换次数要多,因而平均情况下,无论算法怎么优化,时间复杂度不会低于 n*(n-1)/4,也就是 O(n^2)。

    2、内存消耗

    算法的内存消耗可以通过空间复杂度来衡量,冒泡排序仅需要一个变量 tmp 来储存交换的数据,因此空间复杂度为 O(1),空间复杂度为 O(1) 的排序算法,也叫 原地排序算法

    3、排序算法的稳定性

    针对排序算法,有一个重要的衡量指标,就是稳定性,这个概念是说,如果待排序的序列中存在值相等的元素,经过排序之后,相等元素之间原有的先后顺序不变。假如有序列 4,1,2,2,我们把第一个 2 叫 2',第二个2 叫 2'',如果排序之后,为1,2',2'',4 那么这个排序算法就是稳定的,否则就是不稳定的。稳不稳定有什么用吗,值都是一样的?当然有用,因为在软件开发中,要排序的数据不单单是一个属性的数据,而是有多个属性的对象,假如对订单排序,要求金额排序,订单金额相同的情况下,按时间排序。最先想到的方法就是先对金额排序,在金额相同的订单区间内按时间排序,理解起来不难,有没有想过,实现起来很复杂。

    但是借助稳定的排序算法,就很简单了,先按订单时间排一次序,再按金额排一次序就可以了。

    小结

    对排序算法的分析无外乎时间复杂度(最好,最坏,平均),空间复杂度,稳定性这些方面,只要理解其思路,弄明白其适用场景,不需要死记。优化思路可以通过观察分析得出,还有一点,冒泡排序虽然使用了数组存储数据但是并没有使用数组随机访问的特性,因此改用链表这种存储结构,使用冒泡排序仍然是可以实现的,你可以尝试下。

    关注个人微信公众号 somenzz 与你一起学习。

    展开全文
  • Python 算法 08 -- 冒泡排序及其优化-1.jpg (93.27 KB, 下载次数: 0)2020-11-6 21:31 上传Python 算法 08 -- 冒泡排序及其优化-2.jpg (56...[5,4,3,2,1]要求:按从小到大的顺序排序2、分析● 冒泡排序的思路两两比较...
  • Python冒泡排序优化、选择排序、插入排序及优化 1. 冒泡排序 def bubble_sort(alist): '''冒泡排序''' for i in range(len(alist)-1, 0, -1): # i表示每次遍历需要比较次数,逐渐减小 for j in range...
  • 冒泡排序: 基本原理: 1.每两两相邻两个元素依次比较,若前一个元素比后一个元素大,则交换位置。第一轮比较完成后最大数字就跑到了最后一个,第二轮比较完成后第二大数字就跑到了最后倒数第二个。 2.假设...
  • 研究了一下冒泡排序,官方写法是下面这样 list_num = ['0', '0', '1', '1', '2', '2', '3', '3', '4', '4', '5', '5', '6', '6', '7', '7', '8', '8', '9', '9'] print(list_num) a = 0 b = 0 length = len(....
  • Python 如何优化冒泡排序

    千次阅读 2018-07-20 21:56:51
    冒泡排序,英文名称(Bubble Sort)是一种基础交换排序算法,在日常工作中经常会用到,例如:页面数据需按时间先后排序,这本质上也是一种冒泡排序法。 喝过可乐朋友都知道,可乐里面气泡会向上浮,这...
  • #优化冒泡排序python) ''' 记录交换操作发生位置,如果没有发生交换操作,则代表排序已经可以终止 这样一来冒泡排序最好情况下,时间复杂度就从O(n^2)优化到了O(n) ''' def imroved_bubble_sort(l): length =...
  • 1.冒泡排序是最基础排序方式,使用两次for循环完成,内层循环比较两个相邻元素大小,一次循环完找出最大元素放在最后,外层循环有多少个待排元素,循环多少遍,这样两层循环完乱序列表就排序好了,第一次...
  • Python冒泡排序算法及其优化

    万次阅读 多人点赞 2018-09-04 14:19:38
    冒泡排序 所谓冒泡,就是将元素两两之间进行比较,谁大就往后移动,直到将最大元素排到最后面,接着再循环一趟,从头开始进行两两比较,而上一趟已经排好那个元素就不用进行比较了。(图中排好序元素标记为...
  • python 冒泡排序-优化

    2021-02-24 16:31:37
    冒泡排序处理数据原本有序 “”" li = [11,22,44,88,66,55,33] def maopao(li): n = len(li) # 遍历列表长度减1次,最后一个不需要比较 for i in range(1, n): # 创建一个变量flag,用来记录本轮冒泡,是否有数据交换...
  • 1.冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • python实现冒泡排序及其优化

    千次阅读 2018-03-14 00:26:42
    python实现冒泡排序及其优化 冒泡排序是排序算法中比较基础部分,简单原理就是 将数量大小比作轻重不同气泡,轻气泡会冒到重气泡之上思想 最原始排序代码如下: def BubbleSort(numList): if not ...
  • 1.冒泡排序(从大到小):交换发生在内部循环 ...冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n) #!usr/bin/python arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56...
  • 近期很多童鞋在讨论大厂面试的算法题,有部分同学表示一脸懵逼,不知从何下手,还有一一部分同学写的冒泡排序算法是直接从网上复制下来的冒泡排序,大多数都没有考虑时间复杂度,说白了只是实现了冒泡的流程,严格来...
  • 冒泡排序,选择排序python冒泡排序冒泡排序普通冒泡排序优化选择排序选择排序普通选择排序优化 冒泡排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果...
  • 1、遇到情况:对于s = [5, 1, 2, 3, 4]这个列表而言,只执行一次循环即可实现排序,如果继续循环,就是1与2、3、 4进行排序,很浪费时间,所以没必要。 2、解决办法: 增加标示为flag,如果flag为True则表示还要...
  • n = n-1 #实现方法2 def bubble_sort2(my_list): n = len(my_list) for j in range(n-1): for i in range(n-1-j): if my_list[i] > my_list[i+1]: my_list[i],my_list[i+1] = my_list[i+1],my_list[i] #优化,...
  • 说到算法中排序,冒泡排序是最简单一种排序算法了,甚至不学数据结构与算法同学都会使用它。但是你有没有想过可以怎么优化? 什么是冒泡排序:就像水慢慢烧开,气泡从下往上越来越大那样,第一次循环都把n个...
  • 相信冒泡排序已经被大家所熟知,今天看了一篇文章,大致是说在面试时end在了冒泡排序上,主要...首先,大家来看一下原始的python实现的冒泡排序算法: def bubble_sort(nums): for i in range(len(nums) -...
  • 之前的优化是在原有普通的冒泡排序的基础上,加入排序标记,如果检查相邻元素之后发现并没有发生元素顺序的调换,那么则可以看做已经排好序了,直接退出,进行下次循环 虽然效果已经比之前普通的冒泡排序要好很多,...
  • 写在前面,排序算法属于面试中绝对不会错过一道题,不管是原理,手撕,变形,优化,全都是考点。接下来更几篇文章争取全面考虑,从面试官角度解析排序算法以及对应回答~如果喜欢话可以点赞收藏关注!及时...
  • 冒泡排序原理 从第一个元素开始(可以从第一个,也可以从最后一个),相邻两两元素进行比较大小,将较大的那个往后移动,否则,两个元素位置...根据冒泡排序的定义,我们可以用python代码实现 def bubble_sort(it...
  • Python十大排序(上)冒泡排序选择排序插入排序希尔排序归并排序 冒泡排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换...
  • 近期很多童鞋在讨论大厂面试的算法题,有部分同学表示一脸懵逼,不知从何下手,还有一一部分同学写的冒泡排序算法是直接从网上复制下来的冒泡排序,大多数都没有考虑时间复杂度,说白了只是实现了冒泡的流程,严格来...
  • Python 冒泡排序

    2016-02-27 18:01:00
    /usr/bin/env pythone3#通过冒泡排序的方式,把列表进行排序优化前count=0number = [10,5,3,20,7,50,35,21,2,9,1,45,15]total=len(number)for a in range(total): for i in range(len(number)-1): if number[i] >...
  • 冒泡排序算法及其优化Python

    千次阅读 2018-01-07 21:48:09
    冒泡排序的基本特征是只能交换相邻的元素。 从下边界开始,一趟扫描下来,可以把当前最大值顶到上边界; 如果没有发生交换操作,则表示数组是有序的。 ''' #算法一:基本冒泡排序 def BubbleSort_1(arr): #外层...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 139
精华内容 55
关键字:

优化的冒泡排序的python

python 订阅