【python算法学习2】冒泡排序的写法

目的：学习冒泡排序的写法

1 定义

1.1百度百科

冒泡排序_百度百科在程序设计语言中，排序算法主要有冒泡排序、快速排序、选择排序以及计数排序等。冒泡排序（Bubble Sort）是最简单和最通用的排序方法，其基本思想是：在待排序的一组数中，将相邻的两个数进行比较，若前面的数比后面的数大就交换两数，否则不交换；如此下去，直至最终完成排序。由此可得，在排序过程中，大的数据往下沉，小的数据往上浮，就像气泡一样，于是将这种排序算法形象地称为冒泡排序。https://baike.baidu.com/item/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F/4602306?fr=ge_ala

2 冒泡程序

2.1 标准的冒泡程序

def bubble_sort(nums):
    for i in range(len(nums) - 1):  # 这个循环负责设置冒泡排序进行的次数
        for j in range(len(nums) - i - 1):  # j为列表下标
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums

print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))

[8, 12, 19, 22, 32, 33, 45, 97]

2.2 详细的冒泡展开（方便看清楚过程）

• 第1层：循环次数，只循环循环 len(list)-1 次
• 第2层：for j in range(len(nums) - i - 1):  # j为列表下标，后面的已经排好序，只继续比较前面的。
• 不需要全部整个数组比较
• 第2层：挨个比较前面的 j 和 j+1 两个相邻元素

def bubble_sort(nums):
    print("目标进行升序排列的冒泡排序")
    print("最初的nums=",nums)   
    for i in range(len(nums) - 1):  # 这个循环负责设置冒泡排序进行的次数  #且不需要最后1个元素再比了，少1轮
        print("第",i+1,"轮比较--","从第",i,"个元素","开始比较：")
        for j in range(len(nums) - i - 1):  # j为列表下标，后面的已经排好序，只继续比较前面的。
            if nums[j] > nums[j + 1]:
                print("第",j,"和",j+1,"相邻两个元素:",nums[j],">",nums[j+1],"需要交换位置，大的右移",end=",")
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
                print("修改后--","后的nums=",nums) 
        print("第",i+1,"轮比较--","后的nums=",nums,end="\n") 
        print("")
    print("最终的nums=",nums)            
    return nums

print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))

 2.3 运行的过程

目标进行升序排列的冒泡排序
最初的nums= [45, 32, 8, 33, 12, 22, 19, 97]
第 1 轮比较-- 从第 0 个元素 开始比较：
第 0 和 1 相邻两个元素: 45 > 32 需要交换位置，大的右移,修改后-- 后的nums= [32, 45, 8, 33, 12, 22, 19, 97]
第 1 和 2 相邻两个元素: 45 > 8 需要交换位置，大的右移,修改后-- 后的nums= [32, 8, 45, 33, 12, 22, 19, 97]
第 2 和 3 相邻两个元素: 45 > 33 需要交换位置，大的右移,修改后-- 后的nums= [32, 8, 33, 45, 12, 22, 19, 97]
第 3 和 4 相邻两个元素: 45 > 12 需要交换位置，大的右移,修改后-- 后的nums= [32, 8, 33, 12, 45, 22, 19, 97]
第 4 和 5 相邻两个元素: 45 > 22 需要交换位置，大的右移,修改后-- 后的nums= [32, 8, 33, 12, 22, 45, 19, 97]
第 5 和 6 相邻两个元素: 45 > 19 需要交换位置，大的右移,修改后-- 后的nums= [32, 8, 33, 12, 22, 19, 45, 97]
第 1 轮比较-- 后的nums= [32, 8, 33, 12, 22, 19, 45, 97]

第 2 轮比较-- 从第 1 个元素 开始比较：
第 0 和 1 相邻两个元素: 32 > 8 需要交换位置，大的右移,修改后-- 后的nums= [8, 32, 33, 12, 22, 19, 45, 97]
第 2 和 3 相邻两个元素: 33 > 12 需要交换位置，大的右移,修改后-- 后的nums= [8, 32, 12, 33, 22, 19, 45, 97]
第 3 和 4 相邻两个元素: 33 > 22 需要交换位置，大的右移,修改后-- 后的nums= [8, 32, 12, 22, 33, 19, 45, 97]
第 4 和 5 相邻两个元素: 33 > 19 需要交换位置，大的右移,修改后-- 后的nums= [8, 32, 12, 22, 19, 33, 45, 97]
第 2 轮比较-- 后的nums= [8, 32, 12, 22, 19, 33, 45, 97]

第 3 轮比较-- 从第 2 个元素 开始比较：
第 1 和 2 相邻两个元素: 32 > 12 需要交换位置，大的右移,修改后-- 后的nums= [8, 12, 32, 22, 19, 33, 45, 97]
第 2 和 3 相邻两个元素: 32 > 22 需要交换位置，大的右移,修改后-- 后的nums= [8, 12, 22, 32, 19, 33, 45, 97]
第 3 和 4 相邻两个元素: 32 > 19 需要交换位置，大的右移,修改后-- 后的nums= [8, 12, 22, 19, 32, 33, 45, 97]
第 3 轮比较-- 后的nums= [8, 12, 22, 19, 32, 33, 45, 97]

第 4 轮比较-- 从第 3 个元素 开始比较：
第 2 和 3 相邻两个元素: 22 > 19 需要交换位置，大的右移,修改后-- 后的nums= [8, 12, 19, 22, 32, 33, 45, 97]
第 4 轮比较-- 后的nums= [8, 12, 19, 22, 32, 33, 45, 97]

第 5 轮比较-- 从第 4 个元素 开始比较：
第 5 轮比较-- 后的nums= [8, 12, 19, 22, 32, 33, 45, 97]

第 6 轮比较-- 从第 5 个元素 开始比较：
第 6 轮比较-- 后的nums= [8, 12, 19, 22, 32, 33, 45, 97]

第 7 轮比较-- 从第 6 个元素 开始比较：
第 7 轮比较-- 后的nums= [8, 12, 19, 22, 32, 33, 45, 97]

最终的nums= [8, 12, 19, 22, 32, 33, 45, 97]
[8, 12, 19, 22, 32, 33, 45, 97]

3 其他变种的排序，类冒泡排序？

3.1 如下这个排序

 用第i个位置的元素，去与数组里的每个元素比较大小，实现排序

#排序？
list1= [3, 7, 1.5, 2, 5,10,-2,6]
#print(len(list1))=8
for i in range(len(list1)):    #i=range(0~8)=0~7
    for j in range(i + 1):     #j=range(0~(0~7)+1)=0~(1~8)=
        if list1[i] < list1[j]:
            list1[i], list1[j] = list1[j], list1[i]
print(list1)

#排序？
list1= [3, 7, 1.5, 2, 5,10,-2,6]
#print(len(list1))=8
for i in range(len(list1)):    #i=range(0~8)=0~7
    for j in range(i + 1):     #j=range(0~(0~7)+1)=0~(1~8)=
        if list1[i] > list1[j]:
            list1[i], list1[j] = list1[j], list1[i]
print(list1)

[-2, 1.5, 2, 3, 5, 6, 7, 10]
[10, 7, 6, 5, 3, 2, 1.5, -2]

3.2 详细展开

# 变种排序？---全展开
list1= [3, 7, 1.5, 2, 5,10,-2,6]    #list不能太少？
print("最初的list1=",list1)
#print(len(list1))=8

for i in range(len(list1)):    #i=range(0~8)=0~7
    print("第",i,"轮")
    print("index=",i,"的元素")
    for j in range(i + 1):     #j=range(0~(0~7)+1)=0~(1~8)=
        if list1[i] < list1[j]:
            print(list1[i],",",list1[j],"内容交换，修改为→",list1[j],",",list1[i])
            list1[i], list1[j] = list1[j], list1[i]
        else:
            print(list1[i],">=",list1[j],"因此相对位置不变")
    print("现在的list1=",list1)       
print("最终的list1=",list1)

3.3 详细运行过程

最初的list1= [3, 7, 1.5, 2, 5, 10, -2, 6]
从第 0 个元素 找起 与列表里所有元素挨个遍历比较大小
3 >= 3 因此相对位置不变
现在的list1= [3, 7, 1.5, 2, 5, 10, -2, 6]
从第 1 个元素 找起 与列表里所有元素挨个遍历比较大小
7 >= 3 因此相对位置不变
7 >= 7 因此相对位置不变
现在的list1= [3, 7, 1.5, 2, 5, 10, -2, 6]
从第 2 个元素 找起 与列表里所有元素挨个遍历比较大小
1.5 , 3 内容交换，修改为→ 3 , 1.5
3 , 7 内容交换，修改为→ 7 , 3
7 >= 7 因此相对位置不变
现在的list1= [1.5, 3, 7, 2, 5, 10, -2, 6]
从第 3 个元素 找起 与列表里所有元素挨个遍历比较大小
2 >= 1.5 因此相对位置不变
2 , 3 内容交换，修改为→ 3 , 2
3 , 7 内容交换，修改为→ 7 , 3
7 >= 7 因此相对位置不变
现在的list1= [1.5, 2, 3, 7, 5, 10, -2, 6]
从第 4 个元素 找起 与列表里所有元素挨个遍历比较大小
5 >= 1.5 因此相对位置不变
5 >= 2 因此相对位置不变
5 >= 3 因此相对位置不变
5 , 7 内容交换，修改为→ 7 , 5
7 >= 7 因此相对位置不变
现在的list1= [1.5, 2, 3, 5, 7, 10, -2, 6]
从第 5 个元素 找起 与列表里所有元素挨个遍历比较大小
10 >= 1.5 因此相对位置不变
10 >= 2 因此相对位置不变
10 >= 3 因此相对位置不变
10 >= 5 因此相对位置不变
10 >= 7 因此相对位置不变
10 >= 10 因此相对位置不变
现在的list1= [1.5, 2, 3, 5, 7, 10, -2, 6]
从第 6 个元素 找起 与列表里所有元素挨个遍历比较大小
-2 , 1.5 内容交换，修改为→ 1.5 , -2
1.5 , 2 内容交换，修改为→ 2 , 1.5
2 , 3 内容交换，修改为→ 3 , 2
3 , 5 内容交换，修改为→ 5 , 3
5 , 7 内容交换，修改为→ 7 , 5
7 , 10 内容交换，修改为→ 10 , 7
10 >= 10 因此相对位置不变
现在的list1= [-2, 1.5, 2, 3, 5, 7, 10, 6]
从第 7 个元素 找起 与列表里所有元素挨个遍历比较大小
6 >= -2 因此相对位置不变
6 >= 1.5 因此相对位置不变
6 >= 2 因此相对位置不变
6 >= 3 因此相对位置不变
6 >= 5 因此相对位置不变
6 , 7 内容交换，修改为→ 7 , 6
7 , 10 内容交换，修改为→ 10 , 7
10 >= 10 因此相对位置不变
现在的list1= [-2, 1.5, 2, 3, 5, 6, 7, 10]
最终的list1= [-2, 1.5, 2, 3, 5, 6, 7, 10]