精华内容
下载资源
问答
  • python冒泡排序优化

    2021-04-15 09:36:04
    优化的关键点 是对 有序区的 界定(在哪里开始有序) 我们在每一轮排序后,记录下最后一次元素交换的位置,那 该位置就是 无序区的边界 ,再往后 就是有趣 ‘’’ def sort_bubble(tmp_list): # 记录最后一次交换...

    ‘’’
    优化的关键点 是对 有序区的 界定(在哪里开始有序)
    我们在每一轮排序后,记录下最后一次元素交换的位置,那 该位置就是 无序区的边界 ,再往后 就是有趣
    ‘’’

    def sort_bubble(tmp_list):
    
        # 记录最后一次交换的位置
        last_chage_index = 0
        # 无序区的便捷,每次就比较到这里就行了
        
        sort_border = len(tmp_list) -1
        for i in range(len(tmp_list)):
            is_sorted = True
            
            for j in range(sort_border):
                if tmp_list[j] > tmp_list[j + 1]:
                    tmp_list[j], tmp_list[j + 1] = tmp_list[j + 1], tmp_list[j]
                    is_sorted = False
                    last_chage_index = j
    
            sort_border = last_chage_index
            if is_sorted:
                break
        print(tmp_list)
    
    sort_bubble([3,4,2,1,5,6,7,8,9])
    
    展开全文
  • 下面代码是冒泡排序逐步优化,写代码用递归也可以实现。什么冒泡排序就不写了,百度解释很详细。对理论不是很感兴趣。#!/usr/bin/env python3# -*- coding: utf-8 -*-"""===========================# @Time : 2020...

    下面代码是冒泡排序逐步优化,写代码用递归也可以实现。什么冒泡排序就不写了,百度解释很详细。对理论不是很感兴趣。

    #!/usr/bin/env python3

    # -*- coding: utf-8 -*-

    """

    ===========================

    # @Time : 2020/9/19 19:54

    # @File : 冒泡排序.py

    # @Author: adeng

    # @Date : 2020/9/19

    ============================

    """

    import random,time

    list_nums = random.sample(range(0,20000,3),12)

    print(list_nums)

    #---------------------for循环------------------

    count = 0

    for i in range(len(list_nums)):

    pass

    flag = True

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

    count += 1

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

    flag = False

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    if flag:

    break

    print(list_nums)

    # 查看比较多少次

    print("比较的次数为{}".format(count))

    #-------------------------while循环---------------------

    i = 0

    count =0

    while i < len(list_nums):

    j = 0

    while j< len(list_nums)-1 -i:

    count += 1

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

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    j += 1

    i += 1

    print(list_nums)

    print("比较的次数为{}".format(count))

    # 优化冒泡排序

    # ---------------------------优化冒泡排序------------

    i = 0

    count1 =0

    start_time = time.time()

    while i < len(list_nums):

    flag = True # 假设每一趟都没有换行

    j = 0

    while j< len(list_nums)-1 -i:

    count1 += 1

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

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    flag = False # 交换了大小,flag为False

    j += 1

    if flag:

    # 这一趟走完以后,flag依然为True,说明这一趟没有进行数据交换

    break

    i += 1

    end_time = time.time()

    print(f"冒牌排序花费时间{end_time-start_time}秒")

    print(list_nums)

    print("比较的次数为{}".format(count1))

    #------------------------递归----------------------------------

    from typing import List

    def array_init(array: List[int], n:int) -> List:

    i = 0

    j = 1

    while j < len(array):

    if array[i] > array[j]:

    array[i], array[j] = array[j], array[i]

    i += 1

    j += 1

    if n == 1:

    # print("array:",array)

    return array

    return array_init(array, n - 1)

    start_time = time.time()

    print(array_init(list_nums, len(list_nums)))

    end_time = time.time()

    print(f"冒牌排序花费时间{end_time-start_time}秒")

    # ------------------------------封装---------------

    def get_random_list(num:int,length)-> list:

    """

    获取一个随机列表

    @param array: 列表

    @return: 返回一个列表

    """

    return random.sample(range(num),length)

    def sort_iter(list_num:list,reverse=False) -> list:

    """

    @param list_num: 列表排序

    @param reverse: False 升序 True 降序

    @return: 返回列表

    """

    global count

    count = 0

    for i in range(len(list_num)):

    pass

    flag = True

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

    count += 1

    if not reverse:

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

    flag = False

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    else:

    if list_num[j] < list_num[j + 1]:

    flag = False

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    if flag:

    break

    return list_num

    print(sort_iter([3,2,1,10,8,3,6,],reverse=True),count)

    def sort_lists(list_num:list,reverse=False) ->list:

    """

    @param list_num: 列表,元素要是int类型

    @param reverse: False 升序,True降序

    @return: 返回列表

    """

    i = 0

    count = 0 # 统计比较了多少次

    while i < len(list_num):

    flag = True # 假设每一趟都没有换行

    j = 0

    while j < len(list_num) - 1 - i:

    count += 1

    if not reverse:

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

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    flag = False # 交换了大小,flag为False

    else:

    if list_num[j] < list_num[j + 1]:

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    flag = False # 交换了大小,flag为False

    j += 1

    if flag:

    # 这一趟走完以后,flag依然为True,说明这一趟没有进行数据交换

    break

    i += 1

    return list_num

    a = [3,1,5,6,4,3,0]

    sort_lists(a,reverse=True)

    print(a) # [6, 5, 4, 3, 3, 1, 0]

    展开全文
  • 优化冒泡排序: def optimization_bubble(collection): for i in range(len(collection)): flag = False for j in range(len(collection) - i - 1): if collection[j] > colle...

    思想:循环一个序列,比较两个相邻的元素,当第一个元素大于第二个元素时,交换两个元素的位置,直到循环到最后一个元素为止;

    优化版冒泡排序: 

    def optimization_bubble(collection):
    
        for i in range(len(collection)):
    
            flag = False
            for j in range(len(collection) - i - 1):
    
    
                if collection[j] > collection[j+1]:
    
                    collection[j + 1],collection[j] = collection[j],collection[j + 1]
                    flag = True
                    
            if not flag:
    
                return collection
    
        return collection

    优化的地方在于减少循环次数,当排序列表在第二层循环中没有符合条件,就意味着目前的列表已经是排好顺序了,直接返回当前列表就可以了,优化前的冒泡排序则会一层层执行下去,直至第一层循环结束,附上优化前的冒泡排序代码供参考;

     

    原始冒泡排序:

    def bubble_sort(collection):
    
    	for i in range(len(collection)):
    		for j in range(len(collection) - i -1):
    
    			if collection[j] > collection[j + 1]:
    				collection[j+1],collection[j] = collection[j],collection[j+1]
    
    	return collection

    冒泡排序的最优版本又称鸡尾酒排序,也叫双向冒泡排序等等,这是冒泡排序的一种变体,不同之处在于,冒泡排序从低到高序列里的每个元素排序,而鸡尾酒排序从两个方向(低到高,高到底)来回排序,效率更高,代码展示:

    def cocktail_shaker_sort(sorted_list):
    
        for i in range(len(sorted_list) - 1, 0, -1):
            swapped = False
    
            for j in range(i, 0, -1):
                if sorted_list[j] < sorted_list[j - 1]:
                    sorted_list[j], sorted_list[j - 1] = sorted_list[j - 1], sorted_list[j]
                    swapped = True
    
            for j in range(i):
                if sorted_list[j] > sorted_list[j + 1]:
                    sorted_list[j], sorted_list[j + 1] = sorted_list[j + 1], sorted_list[j]
                    swapped = True
    
            if not swapped:
                return sorted_list

     

     

     

    展开全文
  • 一、冒泡排序简介冒泡排序(Bubble Sort)是一种常见的排序算法,相对来说比较简单。冒泡排序重复地走访需要排序的元素列表,依次比较两个相邻的元素,如果顺序(如从大到小或从小到大)错误就交换它们的位置。重复地...
  • 1.冒泡排序(从大到小):交换发生在内部循环稳定的排序冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)冒泡排序优化在于didswap变量 ,通过这个变量的设置,...
  • 1.冒泡排序(从大到小):交换发生在内部循环稳定的排序冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)冒泡排序优化在于didswap变量 ,通过这个变量的设置,...
  • 我对Python相当陌生,我将从...我建议第一个选项是优化冒泡排序,但第二个选项有问题。在维基百科中,这个“允许我们跳过很多元素,结果在最坏的情况下,比较计数提高了大约50%”。所以我的第一个选项的代码看起来...
  • python冒泡排序程序

    2018-02-04 20:35:54
    python冒泡排序程序,优化代码。。,python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序
  • 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、题目假设有一个列表 ...
  • Python冒泡排序优化、选择排序、插入排序及优化 1. 冒泡排序 def bubble_sort(alist): '''冒泡排序''' for i in range(len(alist)-1, 0, -1): # i表示每次遍历需要比较的次数,逐渐减小 for j in range...
  • 普通版: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假设现在有一...
  • 本文地址:http://www.04007.cn/article/647.html...冒牌排序的复杂度是O(N^2),那冒泡排序比较了多少次呢?是不是N^2呢?其实不是。冒泡排序的PHP实现如下示例: a.php:本文地址:http://www.04007.cn/article/647....
  • 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,用来记录本轮冒泡,是否有数据交换...
  • Python冒泡排序算法及其优化

    万次阅读 多人点赞 2018-09-04 14:19:38
    冒泡排序 所谓冒泡,就是将元素两两之间进行比较,谁大就往后移动,直到将最大的元素排到最后面,接着再循环一趟,从头开始进行两两比较,而上一趟已经排好的那个元素就不用进行比较了。(图中排好序的元素标记为...
  • 研究了一下冒泡排序,官方的写法是下面这样的 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(....
  • 冒泡排序优化3.冒泡排序最终优化总结 原理 冒泡排序是一种交换排序,核心是冒泡,把数组中最小的那个往上冒,冒的过程就是和他相邻的元素交换。 重复走访要排序的数列,通过两两比较相邻记录的排序码。排序过程中...
  • 1.冒泡排序(从大到小):交换发生在内部循环 ...冒泡排序优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n) #!usr/bin/python arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56...
  • 说到算法中的排序,冒泡排序是最简单的一种排序算法了,甚至不学数据结构与算法的同学都会使用它。但是你有没有想过可以怎么优化?什么是冒泡排序:就像水慢慢烧开,气泡从下往上越来越大那样,第一次循环都把n个...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作...
  • 1.冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • 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] >...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 215
精华内容 86
关键字:

python冒泡排序优化

python 订阅