Python冒泡排序（4）

Python代码：

"""
冒泡排序（4）

在未排序的数中，通过两两比较[换位]的方式，将最小的数移至首位
N个数排序，则需要执行N-1轮，第1轮比较N-1次，后续每轮比上一轮少比较1次

本例中：
第1轮将0放到正确位置；
第2轮将1放到正确位置；
......
第9轮将8放到正确位置；

此方法中，两个位置数字比较时，两个位置都是变化的
第1轮第1次是位置8、位置9的数字比较，前者大，则互换位置；
第1轮第2次是位置7、位置8的数字比较，前者大，则互换位置；
......
第1轮第9次是位置0、位置1的数字比较，前者大，则互换位置；

第2轮第1次是位置8、位置9的数字比较，前者大，则互换位置；
......
第2轮第8次是位置1、位置2的数字比较，前者大，则互换位置；
......

"""

lst = [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]
print("排序前: %s\r\n" %lst)

# 轮
for i in range(len(lst)-1,0,-1): #[9,8,7,6,5,4,3,2,1]
    print("第%s轮" % (10-i))
    # 次
    for j in range(len(lst)-1,len(lst)-i-1,-1):
        # 如果前大后小，则交换位置
        if lst[j-1] > lst[j]:
            lst[j-1],lst[j] = lst[j],lst[j-1]
            print("    第%s次 [%s]:%s,[%s]:%s比较 互换 %s" % (9-j+1,j-1,lst[j],j,lst[j-1],lst))
        else:
            print("    第%s次 [%s]:%s,[%s]:%s比较 不变 %s" % (9-j+1,j-1,lst[j-1],j,lst[j],lst))

print("\r\n排序后:  %s" % lst)

输出结果：

E:\python\algorithm>python3  bubbleSort4.py
排序前: [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]

第1轮
    第1次 [8]:4,[9]:0比较 互换 [3, 6, 9, 1, 8, 7, 2, 5, 0, 4]
    第2次 [7]:5,[8]:0比较 互换 [3, 6, 9, 1, 8, 7, 2, 0, 5, 4]
    第3次 [6]:2,[7]:0比较 互换 [3, 6, 9, 1, 8, 7, 0, 2, 5, 4]
    第4次 [5]:7,[6]:0比较 互换 [3, 6, 9, 1, 8, 0, 7, 2, 5, 4]
    第5次 [4]:8,[5]:0比较 互换 [3, 6, 9, 1, 0, 8, 7, 2, 5, 4]
    第6次 [3]:1,[4]:0比较 互换 [3, 6, 9, 0, 1, 8, 7, 2, 5, 4]
    第7次 [2]:9,[3]:0比较 互换 [3, 6, 0, 9, 1, 8, 7, 2, 5, 4]
    第8次 [1]:6,[2]:0比较 互换 [3, 0, 6, 9, 1, 8, 7, 2, 5, 4]
    第9次 [0]:3,[1]:0比较 互换 [0, 3, 6, 9, 1, 8, 7, 2, 5, 4]
第2轮
    第1次 [8]:5,[9]:4比较 互换 [0, 3, 6, 9, 1, 8, 7, 2, 4, 5]
    第2次 [7]:2,[8]:4比较 不变 [0, 3, 6, 9, 1, 8, 7, 2, 4, 5]
    第3次 [6]:7,[7]:2比较 互换 [0, 3, 6, 9, 1, 8, 2, 7, 4, 5]
    第4次 [5]:8,[6]:2比较 互换 [0, 3, 6, 9, 1, 2, 8, 7, 4, 5]
    第5次 [4]:1,[5]:2比较 不变 [0, 3, 6, 9, 1, 2, 8, 7, 4, 5]
    第6次 [3]:9,[4]:1比较 互换 [0, 3, 6, 1, 9, 2, 8, 7, 4, 5]
    第7次 [2]:6,[3]:1比较 互换 [0, 3, 1, 6, 9, 2, 8, 7, 4, 5]
    第8次 [1]:3,[2]:1比较 互换 [0, 1, 3, 6, 9, 2, 8, 7, 4, 5]
第3轮
    第1次 [8]:4,[9]:5比较 不变 [0, 1, 3, 6, 9, 2, 8, 7, 4, 5]
    第2次 [7]:7,[8]:4比较 互换 [0, 1, 3, 6, 9, 2, 8, 4, 7, 5]
    第3次 [6]:8,[7]:4比较 互换 [0, 1, 3, 6, 9, 2, 4, 8, 7, 5]
    第4次 [5]:2,[6]:4比较 不变 [0, 1, 3, 6, 9, 2, 4, 8, 7, 5]
    第5次 [4]:9,[5]:2比较 互换 [0, 1, 3, 6, 2, 9, 4, 8, 7, 5]
    第6次 [3]:6,[4]:2比较 互换 [0, 1, 3, 2, 6, 9, 4, 8, 7, 5]
    第7次 [2]:3,[3]:2比较 互换 [0, 1, 2, 3, 6, 9, 4, 8, 7, 5]
第4轮
    第1次 [8]:7,[9]:5比较 互换 [0, 1, 2, 3, 6, 9, 4, 8, 5, 7]
    第2次 [7]:8,[8]:5比较 互换 [0, 1, 2, 3, 6, 9, 4, 5, 8, 7]
    第3次 [6]:4,[7]:5比较 不变 [0, 1, 2, 3, 6, 9, 4, 5, 8, 7]
    第4次 [5]:9,[6]:4比较 互换 [0, 1, 2, 3, 6, 4, 9, 5, 8, 7]
    第5次 [4]:6,[5]:4比较 互换 [0, 1, 2, 3, 4, 6, 9, 5, 8, 7]
    第6次 [3]:3,[4]:4比较 不变 [0, 1, 2, 3, 4, 6, 9, 5, 8, 7]
第5轮
    第1次 [8]:8,[9]:7比较 互换 [0, 1, 2, 3, 4, 6, 9, 5, 7, 8]
    第2次 [7]:5,[8]:7比较 不变 [0, 1, 2, 3, 4, 6, 9, 5, 7, 8]
    第3次 [6]:9,[7]:5比较 互换 [0, 1, 2, 3, 4, 6, 5, 9, 7, 8]
    第4次 [5]:6,[6]:5比较 互换 [0, 1, 2, 3, 4, 5, 6, 9, 7, 8]
    第5次 [4]:4,[5]:5比较 不变 [0, 1, 2, 3, 4, 5, 6, 9, 7, 8]
第6轮
    第1次 [8]:7,[9]:8比较 不变 [0, 1, 2, 3, 4, 5, 6, 9, 7, 8]
    第2次 [7]:9,[8]:7比较 互换 [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
    第3次 [6]:6,[7]:7比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
    第4次 [5]:5,[6]:6比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
第7轮
    第1次 [8]:9,[9]:8比较 互换 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    第2次 [7]:7,[8]:8比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    第3次 [6]:6,[7]:7比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第8轮
    第1次 [8]:8,[9]:9比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    第2次 [7]:7,[8]:8比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第9轮
    第1次 [8]:8,[9]:9比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

排序后:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=====结束=====

原文地址：https://www.cnblogs.com/sam11/p/8342817.html

时间： 2024-10-20 04:06:25

Python冒泡排序（4）的相关文章

冒泡排序的思想 python 冒泡排序

冒泡排序的时间复杂度是O(N^2) 冒泡排序的思想: 每次比较两个相邻的元素, 如果他们的顺序错误就把他们交换位置 比如有五个数: 12, 35, 99, 18, 76, 从大到小排序, 对相邻的两位进行比较 第一趟: 第一次比较: 35, 12, 99, 18, 76 第二次比较: 35, 99, 12, 18, 76 第三次比较: 35, 99, 18, 12, 76 第四次比较: 35, 99, 18, 76, 12 经过第一趟比较后, 五个数中最小的数已经在最后面了, 接下来只比较前四个

python 冒泡排序与快速排序 遇到的错误与问题

今天看了兄弟连php里面的冒泡排序与快速排序,想了下应该可以用python实现. 冒泡排序函数: def mysort(x): len1 = len(x) for i in range(len1-1,0,-1): for j in range(0,i): if x[j]>x[j+1]: x[j],x[j+1]=x[j+1],x[j] return x 第三行代码,是让i的值9到1,因为冒泡排序是大的数往后冒,当第二次循环时,最大的数已经在最后了,所以不需要在比较一次. 同理,第三次,只要让其比较

Python冒泡排序（2）

冒泡排序:通过与相邻元素比较的方式每次将一个数归位 Python代码: """ 冒泡排序(2) 在未排序的数中,通过两两比较[换位]的方式,将最小的数移至首位 N个数排序,则需要执行N-1轮,第1轮比较N-1次,后续每轮比上一轮少比较1次 本例中: 第1轮将0放到正确位置: 第2轮将1放到正确位置: ...... 第9轮将8放到正确位置: """ lst = [3, 6, 9, 1, 8, 7, 2, 5, 4, 0] print("排

Python冒泡排序（6）

前面写了5种冒泡排序,实质只有2种冒泡方式. 第1种是采用相邻两数比较的方式进行排序,第2种是采用与固定位数字比较的方式进行排序. 第1种方式中两个比较的数所处的位置每次都是不同的,第2种方式中两个比较的数所处的位置有一个是不变的. 第1种方式中可以通过添加判断标识的方式减少排序轮次. 例如如下代码中添加了bf标识 Python代码: lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] print("排序前: %s\r\n" %lst) # 轮 for i in

Python—冒泡排序算法

冒泡排序 一,介绍 冒泡排序(Bubble Sort)也是一种简单直观的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 作为最简单的排序算法之一,冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样,每次都在第一页第一位,所以最熟悉.冒泡排序还有一种优化算法,就是立一个 flag,当在一趟

python 冒泡排序，递归

冒泡排序: li = [33, 55, 58, 66, 58, 555,20000000000000000000000, 5555,5555, 5, 6, 62,1] for i in range(1,len(li)): for l in range(len(li)-i): if li[l] >li[l+1]: temp =li[l] li[l]=li[l+1] li[l+1]= tempprint(li) 递归: 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,

python 冒泡排序加入判断

#!/usr/bin/env python #coding:utf-8 import types,sys # 简单的排序 l=[1,9,2,3,-1,724,219,888] for i in range(len(l)): for j in range(i,len(l)): if l[j] > l[i]: l[i],l[j]=l[j],l[i] print l # 定义为函数并加入判断的排序 def sort(list_sort): if type(list_sort) == types.Lis

python 冒泡排序的实现

冒泡排序的基本思想:从第一个元素开始,每每相邻的两个元素进行比较,若前者比后者大则交换位置.最后两个相邻元素比较完成后,最大的元素形成,然后再次从头开始进行比较,若元素个数为n+1个,则总共需要进行n轮比较就可完成排序(n轮比较后,n个最大的元素已经形成,最后一个元素当然是最大的,就不用再比了).每轮比较中,每形成一个最大的元素,下一轮比较的时候 就少比较一次,第一轮需要比较n次,第二轮需要比较n-1次,以此类推,第n轮(最后一轮)只需要比较1次就可.这样,列表就排好序了. def bubble

python冒泡排序

def bubblesort(nums): for i in  range(len(nums)-1): for j in range(len(nums)-i-1): if nums[j]>nums[j+1]: nums[j],nums[j+1]=nums[j+1],nums[j] return nums nums=[3,123,34,43,0,3,6,8] print(bubblesort(nums))