精华内容
下载资源
问答
  • #优化冒泡排序python) ''' 记录交换操作发生的位置,如果没有发生交换操作,则代表排序已经可以终止 这样一来冒泡排序最好的情况下,时间复杂度就从O(n^2)优化到了O(n) ''' def imroved_bubble_sort(l): length =...

    优化冒泡排序(python)

    '''
    记录交换操作发生的位置,如果没有发生交换操作,则代表排序已经可以终止
    这样一来冒泡排序最好的情况下,时间复杂度就从O(n^2)优化到了O(n)
    '''
    def imroved_bubble_sort(l):
        length = len(l)
        swaplast = length - 1
        for i in range(len(l)):
            sign = swaplast
            for j in range(swaplast):
                if l[j] > l[j+1]:
                    temp = l[j+1]
                    l[j + 1] = l[j]
                    l[j] = temp
                    swaplast = j
            if sign == swaplast:
                break
    
    展开全文
  • 1.冒泡排序是最基础的排序方式,使用两次for循环完成,内层循环比较两个相邻元素的大小,一次循环完找出最大的元素放在最后,外层循环有多少个待排元素,循环多少遍,这样两层循环完乱序的列表就排序好了,第一次...
           1.冒泡排序是最基础的排序方式,使用两次for循环完成,内层循环比较两个相邻元素的大小,一次循环完找出最大的元素放在最后,外层循环有多少个待排元素,循环多少遍,这样两层循环完乱序的列表就排序好了,第一次循环8最大,放在最后,第二次6最大放到最后,第三次5最大放到最后,一直到排序完

    在这里插入图片描述

           代码如下:
    def bubble_sort_v1(array):
        #判断传过来的参数是否为数组
        if isinstance(array,list):
            for i in range(len(array)-1):
                for j in range(len(array)-i-1):
                    if array[j] > array[j+1]:
                        array[j],array[j+1] = array[j+1],array[j]
        else:
            print("参数为数组")
    
    list1 = [234,5,3,23,56,666,888]
    bubble_sort_v1(list1)
    print(list1)
    
    结果:
    [3, 5, 23, 56, 234, 666, 888]
    
           2.上面是最基础版的冒泡排序,这个版本有什么可以优化的地方吗?假如有一种情况是这样大的,只需要把最后两个元素换下位置就排序好了,外层循环一次就排好了,可是以上冒泡排序的代码还是要遍历5次,这样效率就不高了,有什么办法解决这种问题吗?

    在这里插入图片描述

           代码如下:设置一个标志,每次内层循环有元素交换位置,就把flag设置为False,如果内层循环没有交换位置,则证明所有元素都排好序了,跳出大循环
    def bubble_sort_v1(array):
        #判断传过来的参数是否为数组
        if isinstance(array,list):
            for i in range(len(array)-1):
                flag = True
                for j in range(len(array)-i-1):
                    if array[j] > array[j+1]:
                        array[j],array[j+1] = array[j+1],array[j]
                        flag = False
                if flag:
                    break
                
        else:
            print("参数为数组")
    
    list1 = [234,5,3,23,56,666,888]
    bubble_sort_v1(list1)
    print(list1)
    
    结果:
    [3, 5, 23, 56, 234, 666, 888]
    
           3.还有一种情况,7,8,9,10已经排好序了,只需要把前面排好序就好了,内层循环第3次就把6放到7前面了,但还是要比较7和8,8和9,知道内层循环完,这种情况怎么优化呢?

    在这里插入图片描述

    代码如下:增加两个变量
    sort_border:内层循环次数
    last_exchange_index:内层最后循环元素交换位置下标
    这样把6放到7前面,last_exchange_index = 3,这样每次内层循环数都会减少,解决以上问题
    def bubble_sort_v1(array):
        #判断传过来的参数是否为数组
        if isinstance(array,list):
            #内层循环边界
            sort_border = len(array) - 1
            #内层最后循环元素交换位置下标
            last_exchange_index = 0
            for i in range(len(array)-1):
                flag = True
                for j in range(sort_border):
                    if array[j] > array[j+1]:
                        array[j],array[j+1] = array[j+1],array[j]
                        flag = False
                        last_exchange_index = j
                sort_border = last_exchange_index
                if flag:
                    break
    
        else:
            print("参数为数组")
    
    list1 = [234,5,3,23,56,666,888]
    bubble_sort_v1(list1)
    print(list1)
    
    结果:
    [3, 5, 23, 56, 234, 666, 888]
    
           以上就是冒泡排序的优化版本了,对你有帮助的话点个赞吧,
    展开全文
  • 本文教大家的是利用Python程序语言编写冒泡排序,下面我们一起来看看吧。为了用python实现各种排序,首先我先创建一个大小为5000的随机列表,公式的写法大概如下:source_list = [random.randint(1, 2000) for i in ...

    所谓冒泡排序,其实是一种在计算机领域里较简单的排序算法。思想就是从数组的第一个元素一个个跟在后面,再挪到相应的位置上去。本文教大家的是利用Python程序语言编写冒泡排序,下面我们一起来看看吧。

    为了用python实现各种排序,首先我先创建一个大小为5000的随机列表,公式的写法大概如下:

    source_list = [random.randint(1, 2000) for i in range(5000)]

    然后再写一个装饰器,打印排序的耗时和排好序的新列表,装饰器如下:

    571f08fb5fc78.png

    下面我们先来做一个冒泡排序,看到这里一定有人不知道什么是冒泡排序,理科出身的同学应该容易理解,就是比较相邻的元素。如果第一个比第二个大,就交换他们两个,对第0个到第n-1个数据做同样的工作。这时,最大的数就“浮”到了数组最后的位置上。以上就是冒泡排序的概念,这下你该知道什么叫冒泡排序了吧。

    针对所有的元素重复以上的步骤,除了最后一个,持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。说再多也不及你做一遍来的好,代码如图。

    附上代码:

    571f094ea560e.png

    终端输出为:bubble_sort 0.626999855042 [1, 1, 1, 1, 1, 1, 2, 2, 2, 4, 5, 6, 6,...

    冒泡很简单,但是大家都知道效率并不高,看到输出结果你不难发现其循环效果太明显了,而且python的for循环效率更是恶心,双重循环的次数又那么多。好在平时并不用冒泡,只是为了理解冒泡排序。

    下面我们看看选择排序,什么是选择排序呢?就是在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的后面。以此类推,直到所有元素均排序完毕。

    代码附上:

    571f099e0a74f.png

    终端输出为:select_sort 0.25200009346 [1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 6,...

    我们用选择排序和冒泡排序做个比较,不难发现选择排序效率远远高于冒泡排序,从代码上不难理解冒泡排序的交换次数远远多于选择排序的交换次数。这样一比较,选择排序比冒泡排序简洁多了。

    再来看一个扩展,利用python的语言特色 min 和list.remove() 完成选择排序。

    571f09e405d93.png

    终端输出为:select_sort1 0.133999824524 [1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6,...

    python的 min 和list.remove() 组合的效率更是优秀,实操起来也不难,有兴趣的朋友有时间可以试试啊。

    下面来看一个插入排序,什么是插入排序呢?来看一下插入排序的步骤:

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

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

    3,如果被扫描的元素(已排序)大于新元素,将该元素后移一位。

    4,重复步骤3,直到找到已排序的元素小于或者等于新元素的位置,将新元素插入到该位置后。

    5,重复步骤2~5。

    代码如下:

    571f0a2a6389c.png

    终端输出的结果:insert_sort 0.242000102997 [1, 4, 4, 6, 6, 6, 6, 7, 9,...

    再来演示一个快速排序,什么是快速排序呢?上面演示了冒泡排序、选择排序、插入排序,现在讲快速排序,希望大家不要混淆了。快速排序是从数列中挑出一个元素作为基准数。分区过程,将比基准数大的放到右边,小于或等于它的数都放到左边。再对左右区间递归执行第二步,直至各区间只有一个数。

    代码送上:

    571f0a853c137.png

    看一下终端的输出:qu_sort 0.00799989700317 [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, ...

    你可以从中对比发现,快速排序的效率超级高的,所以小编认为,数据量大的时候用快排是比较好的,唯一担心的就是递归的深度,所以结合实际情况吧。有兴趣学习的朋友可以把代码优化一下,然后拿出来给大家分享学习。

    本文讲述用python实现冒泡排序、选择排序等等,也罗列了详细地编码共大家参考学习。你看到后是不是觉得冒泡排序挺有趣,其他类型的排序也很好玩,有空大家可以用python试试。

    展开全文
  • 冒泡排序 python实现

    2020-04-13 11:30:48
    冒泡排序 python实现简介思路分析代码引用 简介 冒泡排序(Bubble Sort),是一种较简单的排序算法。 它重复地遍历要排序的元素列,依次比较两个相邻的元素,如果顺序错误就交换这两个元素,直到没有相邻元素需要...

    冒泡排序 python实现

    简介

    冒泡排序(Bubble Sort),是一种较简单的排序算法。

    它重复地遍历要排序的元素列,依次比较两个相邻的元素,如果顺序错误就交换这两个元素,直到没有相邻元素需要交换,此时该元素列排序完成。

    这个算法的名字由来:越大的元素会经过交换慢慢“浮”到数列的顶端(升序),就像气泡最终会上浮到顶端一样,故名“冒泡排序”。

    思路

    (以升序为例)比较两个相邻的元素,将较大的元素放在较小的元素后面。

    (1)第一次比较:比较第一个元素和第二个元素,并按序排列这两个数;
    (2)第二次比较:比较第二个元素和第三个元素,并按序排列这两个数;
    (3)按这种方法,一直比较到最后一个元素,并按序排列这两个数;
    (4)此时第一趟比较结束,元素列中的最后一个元素一定是最大的数,因此,下一趟比较中,比较次数减一;
    (5)按照步骤1到3进行第二趟比较,完成后倒数第二个数一定是第二大的数,因此,下一趟比较中,比较次数继续减一;
    (6)以此类推,直到元素列有序。

    例子:升序排序元素列 [3, 5, 4, 6, 1, 2],需要比较5趟。

    在这里插入图片描述

    分析

    特点:每一趟排序后就会少比较一次,一定程度上减少了计算量。

    时间复杂度:如果元素列本身就是正序,那么第一趟比较即可完成排序,所以最好的时间复杂度为O(N);如果元素列是反序的,那么需要(N - 1)趟排序,第 i 趟排序需要进行(N - i)次比较,此时时间复杂度为O(N2),因此平均时间复杂度为O(N2)。

    代码

    普通冒泡排序

    def bubbleSort(List):
    	size = len(List)
    	#外循环
    	for i in range(size-1):
    		for j in range(size-1-i):
    			if List[j] > List[j+1]:
    				List[j], List[j+1] = List[j+1], List[j]
    	return List
    

    从上述代码中我们可以看到,即使元素列本身是正序,但仍需要比较N趟才能结束。因此,我们对其进行了优化,使元素列有序后跳出循环。

    优化冒泡排序

    def bubbleSort(List):
    	size = len(List)
    	#外循环
    	for i in range(size-1):
    		didSwap = False
    		for j in range(size-1-i):
    			if List[j] > List[j+1]:
    				List[j], List[j+1] = List[j+1], List[j]
    				didSwap = True
    		if didSwap == False:
    			break
    	return List
    

    引用

    百度百科-冒泡排序
    三分钟彻底了解冒泡排序
    冒泡排序的最佳时间复杂度为什么是O(n2)

    展开全文
  • Python 如何优化冒泡排序

    千次阅读 2018-07-20 21:56:51
    冒泡排序,英文名称(Bubble Sort)是一种基础的交换排序算法,在日常工作中经常会用到,例如:页面数据需按时间先后排序,这本质上也是一种冒泡排序法。 喝过可乐的朋友都知道,可乐里面的气泡会向上浮,这...
  • 所谓冒泡排序,就是小的数越来越靠前,大的数越来越往后 第一次遍历整个列表,如果前一个数比后一个数大,交换位置,直到比较完最后两个数时,会将整个列表中最大的数沉到列表最后一个,所以第二次遍历就只需要遍历...
  • (通俗易懂 图文并茂)算法入门之冒泡排序Python

    千次阅读 多人点赞 2020-05-17 19:06:52
    文章目录前言什么是冒泡排序Python代码补充说明 前言 这里我们就直接简单粗暴的给原理跟代码看完之后在看一些比较官方的说明!! 如果开头看不明白的先看 补充说明。 如果只想看代码的直接点目录的 Python代码 有两...
  • 冒泡排序,选择排序python冒泡排序冒泡排序普通冒泡排序优化选择排序选择排序普通选择排序优化 冒泡排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果...
  • python冒泡排序程序

    2018-02-04 20:35:54
    python冒泡排序程序,优化代码。。,python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序
  • Python冒泡排序优化、选择排序、插入排序及优化 1. 冒泡排序 def bubble_sort(alist): '''冒泡排序''' for i in range(len(alist)-1, 0, -1): # i表示每次遍历需要比较的次数,逐渐减小 for j in range...
  • 冒泡排序原理 从第一个元素开始(可以从第一个,也可以从最后一个),相邻两两元素进行比较大小,将较大的那个往后移动,否则,两个元素位置...根据冒泡排序的定义,我们可以用python代码实现 def bubble_sort(it...
  • Python中的冒泡排序算法冒泡排序是最直接的排序算法之一。它的名字来自于算法的工作方式:每经过一个新遍历,列表中最大的元素就会向正确的位置“冒泡”。冒泡排序包括对列表进行多次遍历、逐个比较元素以及交换顺序...
  • 1.冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • 目录冒泡排序原理基础版冒泡排序代码- 无注释版,精简代码- 有注释版,并添加辅助行理解代码进阶版冒泡排序代码(施工中)1. 冒泡排序算法(原理)比较相邻的元素。如果第一个比第二个大,就交换他们两个。最后的...
  • Python 中常见的排序算法有:冒泡排序、快速排序、插入排序、选择排序、归并排序、堆排序、二叉树排序。今天给大家分析下冒泡排序,什么是冒泡排序呢?以下是百度百科的解释:冒泡排序(Bubble Sort),是一种计算机...
  • 冒泡排序算法原理冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访...
  • 优化Python实现(傻帽排序法) 维基百科: 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地...
  • Python 中常见的排序算法有:冒泡排序、快速排序、插入排序、选择排序、归并排序、堆排序、二叉树排序。今天给大家分析下冒泡排序,什么是冒泡排序呢?以下是百度百科的解释:冒泡排序(Bubble Sort),是一种计算机...
  • 一 、冒泡排序:冒泡排序:属于交换排序;两两比较大小,交换位置,如同水泡大的往上(右)跑;n个数从左至右编号从0到n-1,索引0和1比较,如果索引0大,则交换两者位置;如果索引1大则不用交换继续比较索引1和2的值,将大值放在...
  • python冒泡排序优化

    2021-04-15 09:36:04
    优化的关键点 是对 有序区的 界定(在哪里开始有序) 我们在每一轮排序后,记录下最后一次元素交换的位置,那 该位置就是 无序区的边界 ,再往后 就是有趣 ‘’’ def sort_bubble(tmp_list): # 记录最后一次交换...
  • 冒泡排序优化3.冒泡排序最终优化总结 原理 冒泡排序是一种交换排序,核心是冒泡,把数组中最小的那个往上冒,冒的过程就是和他相邻的元素交换。 重复走访要排序的数列,通过两两比较相邻记录的排序码。排序过程中...
  • 冒泡排序_Python实现

    2019-08-15 17:02:13
    冒泡排序是最基础的排序算法 什么是冒泡排序?? 冒泡排序是一种基础的交换排序。 冒泡、冒泡就像水中的气泡一样,不断的往上漂浮,而冒泡算法之所以叫冒泡算法,正是因为这种算法的每一个元素都可以像小气泡一样,...
  • 冒泡排序实现思路 : 使用双重for循环,内层变量为i, 外层为j,在内层循环中不断的比较相邻的两个值(i, i+1)的大小,如果i+1的值大于i的值,交换两者位置,每循环一次,外层的j增加1,等到j等于n-1的时候,结束...

空空如也

空空如也

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

优化的冒泡排序的python

python 订阅