算法学习：冒泡排序

1、思路

对于数组s：

　　每一轮，遍历数组，比较相邻的两个数，交换位置，大的放后面；

　　第一轮，得到最大的数，比较len(s) - 1 次

　　第二轮，得到第二大的数。。。。

　　第len(s)-1轮，得到第2小和最小的数。

　　所以要比较len(s)-1 轮。

 

2、举例

原始数组：[9,5,4,3,2]

第一轮

　　• 第一次：9>5==>[5,9,4,3,2]

　　• 第二次：9>4==>[5,4,9,3,2]

　　• 第三次：9>3==>[5,4,3,9,2]

　　• 第四次：9>2==>[5,4,3,2,9]

第一轮排序结果：[5,4,3,2,9]

 

第二轮

　　• 第一次：5>4==>[4,5,3,2,9]

　　• 第二次：5>3==>[4,3,5,2,9]

　　• 第三次：5>2==>[4,3,2,5,9]

第二轮排序结果：[4,3,2,5,9]

 

第三轮

　　• 第一次：4>3==>[3,4,2,5,9]

　　• 第二次：4>2==>[3,2,4,5,9]

第三轮排序结果：[3,2,4,5,9]

 

第四轮

• 第一次：3>2==>[2,3,4,5,9]

结果：[2,3,4,5,9]

 

3、总结

对于一个长度为n的数组，进行排序归纳总结：

　　1 对于有n个元素的数组进行排序，需要经过n-1轮

　　2 第i轮比较的次数为 n-i

 

4、代码

def bubble(arr):
    length = len(arr)
    #控制排序的轮数
    for i in range(length-1):
        #控制排序的次数
        print('第%s轮'%(i+1))
        for j in range(length-1-i):
            print('比较第%s和第%s个数：'%(j,j+1))
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]
                print('比较排序的结果是：',arr)
    return arr

arr=[9,5,4,3,2]
print(bubble(arr))

结果：

D:>py -3 a.py
第1轮
比较第0和第1个数：
比较排序的结果是： [5, 9, 4, 3, 2]
比较第1和第2个数：
比较排序的结果是： [5, 4, 9, 3, 2]
比较第2和第3个数：
比较排序的结果是： [5, 4, 3, 9, 2]
比较第3和第4个数：
比较排序的结果是： [5, 4, 3, 2, 9]
第2轮
比较第0和第1个数：
比较排序的结果是： [4, 5, 3, 2, 9]
比较第1和第2个数：
比较排序的结果是： [4, 3, 5, 2, 9]
比较第2和第3个数：
比较排序的结果是： [4, 3, 2, 5, 9]
第3轮
比较第0和第1个数：
比较排序的结果是： [3, 4, 2, 5, 9]
比较第1和第2个数：
比较排序的结果是： [3, 2, 4, 5, 9]
第4轮
比较第0和第1个数：
比较排序的结果是： [2, 3, 4, 5, 9]
[2, 3, 4, 5, 9]

5、时间复杂度

使用两层循环即可实现我们的冒泡排序的算法：

　　I.使用for循环控制排序的轮数，排序的轮数为 len(s) - 1

　　II.内层嵌套循环控制每轮排序的次数，每轮排序的次数为n-i

　　III.排序过程中依次比较arr[i]与arr[i+1]，大的放后面

　　IV.外层循环结束后返回原数组

时间复杂度：O(n^2)