排序算法(1)——冒泡排序

__author__ = 'steven'
# coding=utf-8
'''冒泡排序
排序过程:
    沉淀法(比大，大的下沉):(visualgo上面的动态图就是沉淀法)
        第 1 次从 头 开始比较前后两个数字的大小，最大的数沉淀在第 n 位置，比较n-1次;
        第 2 次从 头 开始比较前后两个数字的大小，次大的数沉淀在第 n-1 位置，比较n-2次;
        ...
        第 n-1 次从头开始比较前后两个数字的大小，次小的数沉淀在第 2 位置，比较1次;
        === 此时，最小数和次小数经过第n-1次比较，最小数已经在第1个位置了 ===
        第 n 次，该比较为无意义的，子循环条件也证明了:range(1，1)，为空，没有比较操作了，比较0次.

    冒泡法(比小，小的上浮):
        第 1 次从 最后 开始比较前后两个数字的大小，最小的数浮在在第 1 位置，比较n-1次;
        第 2 次从 最后 开始比较前后两个数字的大小，次小的数浮在在第 2 位置，比较n-2次;
        ...
        第 n-1 次从 最后 开始比较前后两个数字的大小，次大数数浮在第 n-1 位置，比较1次;
        === 此时，最大数和次大数经过第n-1次比较，最大数已经被"浮"(沉淀)在第 n 个位置了 ===
        第 n 次，该比较为无意义的，子循环条件也证明了:range(n-1，n-1)，直接返回上一次的list，比较0次.

    所以，外层循环条件可以写 range(n-1):循环总次数为: n-1 + n-2 + ... + 1
        也可以写range(n):循环总次数为: n-1 + n-2 + ... + 1 + 0

    平均时间复杂度为O(n^2);
    最好情况(顺序)为O(n);
    最坏情况(倒序)为O(n^2):n-1 + n-2 + ... + 1=n(n-1)/2
    算法稳定.

    改进的bubble_sort,因为冒泡排序的在当前子循环过程中,除了把当前最大数沉淀到最后,
    在比较的过程中,会对当前遍历中的每个数进行比较,在到达最后的过程中,期间如果没有任何
    交换操作,说明,当前遍历的已经是顺序的了,无需要在做后面的遍历了.现对每个遍历
    加一个标志,什么时候整个遍历没有交换操作,则整个排序终止.
'''

list = [5, 8, 1, 4, 2, 7, 3, 6]
list_ascended = [1, 2, 3, 4]
list_descended = [5, 4, 3, 2]

def bubble_sort(list):
    n = len(list)
    for i in range(n):  # 参数为 n 话,i从0到n-1,一共遍历 n 次
        print(list)
        flag = True
        # 向下沉淀
        # for j in range(1, n - i):  # 以1为起点(从0开始比较),n-i为终点,向后遍历;
        #     if list[j - 1] > list[j]: # 每次子循环从最开始开始向下沉,沉淀到 n-i 为止
        #         list[j - 1], list[j] = list[j], list[j - 1]
        # 向上冒泡
        for j in range(n - 1, i, -1):  # 以n-1为起点,i为终点,向前遍历(j取值范围为[n-1,i+1])
            if list[j] < list[j - 1]:   # 每次子循环从最底下向上冒,冒到 i 为止
                list[j - 1], list[j] = list[j], list[j - 1]
                flag = False  # 一次交换都没有 flag 才能保持住原始的标志
        if flag == True:
            return list
    return list

print(bubble_sort(list))
print('-----')
print(bubble_sort(list_ascended))
print('-----')
print(bubble_sort(list_descended))




# list = [5, 8, 1, 4]

# def bubble_sort(list):
#     n = len(list)
#     for i in range(n - 1):
#         print(list)
#         print('----')
#         print("i	%d"%i)

#         # # 向下沉淀
#         for j in range(1, n - i):  # 每次子循环从最开始开始向下沉,沉淀到 n-i 为止
#             if list[j - 1] > list[j]:
#                 list[j - 1], list[j] = list[j], list[j - 1]
#             print("j	%d"%j)
#
#         # # 向上冒泡
#         # for j in range(n - 1, i, -1):  # 每次子循环从最底下向上冒,冒到 i 为止
#         #     if list[j] < list[j - 1]:
#         #         list[j - 1], list[j] = list[j], list[j - 1]
#     return list

# print(bubble_sort(list))