数据结构与算法（python版）（八）——冒泡排序

数据结构与算法（python版）（八）

*排序算法（Sorting Algorithm）的稳定性

稳定排序算法会让原本有相等值的记录维持相对次序；
不稳定排序算法可能会在相等的值中改变记录的相对次序。

1、冒泡排序（Bubble sort）

重复地遍历要排序的数列，一次比较两个元素，如果两个元素顺序错误则进行交换位置，遍历数列的工作重复进行直到不需要再进行交换。越大的元素会经过交换“浮”到数列的顶端。

2、冒泡排序算法运作

• 比较相邻两个元素，如果第一个比第二个大，则交换两者
• 对每一对相邻元素做同样的工作，从头遍历到最后一位，最终最大的元素会交换到最后
• 对所有的元素重复以上过程，除最后一位
• 每次重复元素会越来越少，直到没有任何数字需要交换

3、冒泡排序实现

def bubble_sort(alist):
    #冒泡排序
    #操作元素下标便于交换元素位置
    n = len(alist)
    for j in range(n-1):
        for i in range(n-1-j):  #从头到尾遍历一遍
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]

#j = 0 , i  0～n-2 , range(0, n-1)
#j = 1 , i  0～n-3 , range(0, n-2)
#j = 2 , i  0～n-4 , range(0, n-3)
                

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    bubble_sort(li)
    print(li)
    

4、冒泡排序实现改进

判断原序列是否有序，已经有序的话不再一次次遍历，直接退出

def bubble_sort(alist):
    #冒泡排序
    #操作元素下标便于交换元素位置
    n = len(alist)
    count = 0  #设置交换次数的计数器
    for j in range(n-1):
        for i in range(n-1-j):  #从头到尾遍历一遍
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
                count += 1
        #如果某次从头到尾的内层遍历没有进行交换，说明已经有序，直接退出
        if count == 0:
            return
        
#j = 0 , i  0～n-2 , range(0, n-1)
#j = 1 , i  0～n-3 , range(0, n-2)
#j = 2 , i  0～n-4 , range(0, n-3)
                

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    bubble_sort(li)
    print(li)
    

5、冒泡排序的时间复杂度

最优时间复杂度：O(1)（改进后）

最坏时间复杂度：O($n^2$)（改进前）

稳定