排序复习python

1.冒泡排序法(Bubble Sort)
基本思想：
将待排序的元素看做是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该
  会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  python实现：

def bubble(array):
    lens = len(array)
    while lens > 0:
        for i in range(len(array)-1):
            if array[i] > array[i+1]:
                array[i],array[i+1] = array[i+1],array[i]
        lens -= 1
        print(array)
    return array

if __name__ == '__main__':
    bubble([4,1,9,13,34,26,10,7,4])

算法是稳定的，复杂度为 O(n^2)
2. 插入排序
是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法稳定性与时间复杂度：
算法是稳定的，复杂度为 O(n^2)
让数值依此和后边的数作比较，大于，则两个数值交换

def insert(array):
    for i in range(1,len(array)):
        while i != 0:
            if array[i] < array[i-1]:
                array[i-1],array[i] = array[i],array[i-1]
                i -= 1
            else:
                break
        print(array)

insert([1,3,2,4,3,2,5])

3 快速排序
快速排序是对冒泡排序的一种本质改进，快速排序通过一趟扫描，就能确保某个数的左边各数都比它
小，右边各数都比它大
算法稳定性与时间复杂度：
算法是不稳定的，复杂度为 O(nlog2n),最坏为 O(n^2)

def quick_sort(array,l,f):
    if l < f:
        base = array[l]
        low = l
        high = f
        while low < high:
            while low < high and array[high] >= base:
                high -= 1
            array[low] = array[high]
            while low < high and array[low] <= base:
                low += 1
            array[high] = array[low]
        array[low] = base

        quick_sort(array,l,low-1)
        quick_sort(array,low+1,f)

    else:
        return

if __name__ == '__main__':
    li=[12, 90, 89, 23, 67, 32, 0, 123, 78]
    print(li)
    quick_sort(li,0,len(li)-1)
    print(li)