数据结构和算法-排序算法-冒泡排序

"""

排序算法，
我们想要把线性表中的无序序列，排成有序序列，的算法，就是排序算法，

排序算法的稳定性
举例：假设对下面的元组要以他们的第一个数字来排序。
(4, 1)  (3, 1)  (3, 7)（5, 6）
如果你排序之后，(3, 1)  (3, 7)和原来的顺序一样，就是稳定的，否则就是不稳定的，
(3, 1)  (3, 7)  (4, 1)  (5, 6)  （维持次序）
(3, 7)  (3, 1)  (4, 1)  (5, 6)  （次序被改变）

我们说排序就是默认从小到大的，

"""

"""

冒泡排序思路

判断本数字和下一个数字的关系，
第一种情况，如果本数字大，把游标和本数字都往后移动，
第二种情况，如果本数字小，本数字不动，游标往后移动，
这样从前到后一轮走下来，最大的数字就移动到最后面了，
然后再执行一轮，一直执行，直到都排好了，

所以设计思路一定是两个循环，
1，内层循环负责从第一个数字开始往后和每一个数字比较，如果遇到比本数字小的就交换位置，继续本数字和下面的数字比较，如果比本数字大，就本数字不动，游标往下，
2，外层循环负责内层循环的次数，因为每次内层循环都会把最大的放到最后，所以越往后循环的次数就是依次减一
"""

# 第一版
def bubble_sort(alist):
    n=len(alist)
    for j in range(0,n-1):
        """
            这是走一轮，只需要走到倒数第二个数字就可以了，所以结尾是n-1，结尾不包含，
            j=0  内循环停止是走到n-2  range(0,n-1)
            j=1  内循环停止是走到n-3  range(0,n-2)
            j=2  内循环停止是走到n-4  range(0,n-3)
            j=n                       range(n-1-j)
        """
        for i in range(n-1-j):
            if alist[i] >alist[i+1]:
                alist[i],alist[i+1]=alist[i+1],alist[i]

# 难点就是range这个地方，先写内层循环，就是走一轮，外层循环控制走几轮，

# 第二版
def bubble_sort2(alist):
    for j in range(len(alist)-1,0,-1):
        """
        range(len(alist)-1,0,-1)
        这个产生的序列是：  n-1  n-2  n-3 .... 1 
        外层还是在控制内存循环的次数，
        """
        # j表示每次遍历需要比较的次数，是逐渐减小的
        for i in range(j):  # 这个循环还是在控制每次循环他所走的步数，
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]

# 这两种方式，他们的最坏时间复杂度都是n的平方，

# 第三版：

# 对于一个有序的序列，[1,2,3,4,5,6]
# 是否可以简化这个过程，怎么优化这个程序，
# 如果从头走到尾，不需要我交换，就说明一遍就足够了，说明就是有序的了，
# 怎么实现，
def bubble_sort3(alist):
    n=len(alist)
    for j in range(0,n-1):
        count = 0
        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 0 == count:
            break

# 这种最优的时间复杂度就是n，最坏的时间复杂度还是n的平方，
if __name__ == "__main__":
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    bubble_sort(li)
    print(li)