数据结构与算法 | 排序 | 排序算法稳定性&冒泡排序

# CY3761 | 2021-12-16 11:23
# 排序算法稳定性&冒泡排序

"""
排序算法的稳定性
稳定的排序算法会让原本有相等键值的记录维持相对次序
不稳定的排序算法可能会改变相等键值的记录的相对次序

6个格子
0 1 2 3 4 5 | 索引
3 1 2 1 4 5 | 值

升序排序 (稳定, 值相等时使用索引进行排序)
1 3 2 0 4 5 | 原索引
1 1 2 3 4 5 | 排序后结果

升序排序 (不稳定, 值相等时不一定使用索引进行排序)
3 1 2 0 4 5 | 原索引 (这里的索引就不一定按顺序了)
1 1 2 3 4 5 | 排序后结果

如果其值是个元祖 (以元祖第一个值进行排序)
(3,0) (1,1) (2,2) (1,3) (4,4) (5,5)
(1,1) (1,3) (2,2) (3,0) (4,4) (5,5) | 稳定
(1,3) (1,1) (2,2) (3,0) (4,4) (5,5) | 不稳定 (元祖第二个值就不一定匹配)
"""

"""
冒泡排序
重复比较相邻的元素,如果前面的比后面的大,就交换它们两个
每次遍历整个数组,遍历完成后,下一次遍历的范围往左缩1位
重复前面步骤,直到排序完成
"""

"""
[6, 5, 4, 3, 2, 1]
第1趟 (前面的比后面的大,就交换它们两个)
[6, 5], 4, 3, 2, 1 | 6 > 5 | [5, 6], 4, 3, 2, 1
5, [6, 4], 3, 2, 1 | 6 > 4 | 5, [4, 6], 3, 2, 1
5, 4, [6, 3], 2, 1 | 6 > 3 | 5, 4, [3, 6], 2, 1
5, 4, 3, [6, 2], 1 | 6 > 2 | 5, 4, 3, [2, 6], 1
5, 4, 3, 2, [6, 1] | 6 > 1 | 5, 4, 3, 2, [1, 6] (6可以固定)

第2趟 (前面的比后面的大,就交换它们两个)
[5, 4], 3, 2, 1, 6 | 5 > 4 | [4, 5], 3, 2, 1, 6
4, [5, 3], 2, 1, 6 | 5 > 3 | 4, [3, 5], 2, 1, 6
4, 3, [5, 2], 1, 6 | 5 > 2 | 4, 3, [2, 5], 1, 6
4, 3, 2, [5, 1], 6 | 5 > 1 | 4, 3, 2, [1, 5], 6 (5可以固定)

第3趟 (前面的比后面的大,就交换它们两个)
[4, 3], 2, 1, 5, 6 | 4 > 3 | [3, 4], 2, 1, 5, 6
3, [4, 2], 1, 5, 6 | 4 > 2 | 3, [2, 4], 1, 5, 6
3, 2, [4, 1], 5, 6 | 4 > 1 | 3, 2, [1, 4], 5, 6 (4可以固定)

第4趟 (前面的比后面的大,就交换它们两个)
[3, 2], 1, 4, 5, 6 | 3 > 2 | [2, 3], 1, 4, 5, 6
2, [3, 1], 4, 5, 6 | 3 > 1 | 2, [1, 3], 4, 5, 6  (3可以固定)

第5趟 (前面的比后面的大,就交换它们两个)
[2, 1], 3, 4, 5, 6 | 2 > 1 | [1, 2], 3, 4, 5, 6   (2可以固定)

冒泡排序结束
排序的到 1, 2, 3, 4, 5, 6
循环次数 n - 1 (n元素个数)
"""


def bubbleSort(*args):  # O(n**2)
    args = list(args)  # 因为参数返回的是元祖 而元祖是不可变的
    l = len(args) - 1  # 的到参数长度 - 1 | 假设6
    
    # print(args, n)
    
    for i in range(l):  # 0~5 不包含5 | 0,1,2,3,4 (这里仅一趟)
        print('第%s趟' % (i + 1))
        isSort = False  # 单趟是否进行排序 (大小值交换)
        for k in range(l - i):
            p, n = k, k + 1
            
            print(args[p], args[n], '|', args, '|', args[p] > args[n], end=' ')
            
            if args[p] > args[n]:
                args[p], args[n] = args[n], args[p]
                isSort = True
            
            print('|', args[p], args[n], '|', args)
            
        if not isSort:  # 如果单趟没有进行排序 (大小值交换) 就可以结束循环了
            break
        
        print()
    
    print(args)


if __name__ == '__main__':
    bubbleSort(6, 5, 4, 3, 2, 1)  # n(n**2)
    bubbleSort(1, 2, 3, 4, 5, 6)  # O(n)