排序算法

1、冒泡排序

冒泡排序（英语：Bubble Sort）是一种简单的排序算法。 它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。 直到没有再需要交换，该数列排序完成

升序排序过程 比较相邻的元素。如果第一个比第二个大，就交换他们两个 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 需要进行n-1次冒泡过程

def bubble_sort(data):
    # 最差一共要遍历比较len(data)-1次
    for i in range(len(data)-1):
        # 第一次比较len(data)-1次
        for j in range(len(data)-i-1):
            if data[i] > data[i+1]:
                data[i], data[i+1] = data[i+1], data[i]
    return data

冒泡排序的最优时间复杂度是O(n)，最坏时间复杂度O(n^2)，是稳定的

2、选择排序

首先在未排序序列中找到最小（大）元素 存放到排序序列的起始位置 再从剩余未排序元素中继续寻找最小（大）元素 放到已排序序列的末尾。 以此类推，直到所有元素均排序完毕。

def select_sort(data):
    for i in range(len(data)-1):
        temp = i
        for j in range(len(data)-i-1):
            if data[temp] > data[i+j+1]:
                temp = i+j+1
        data[i], data[temp] = data[temp], data[i]
    return data

最优时间复杂度：O(n2) 最坏时间复杂度：O(n2) 稳定性：不稳定（考虑升序每次选择最大的情况）

3、插入排序

通过构建有序序列 对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

def insert_sort(data):
    # 一共要遍历比较len(data)-1次
    for i in range(len(data)-1):
        temp = i
        # 第一次比较前两个 第二次比较前三个 从后向前开始比较
        while temp >= 0:
            if data[temp] > data[temp+1]:
                data[temp], data[temp + 1] = data[temp + 1], data[temp]
            temp = temp-1
    return data

最优时间复杂度：O(n)（升序排列，序列已处于升序状态） 最坏时间复杂度：O(n2) 稳定性：稳定

4、快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort） 将要排序的数据分割成独立的两部分 其中一部分的所有数据都比另外一部分的所有数据都要小 然后再按此方法对这两部分数据分别进行快速排序 整个排序过程可以递归进行 以此达到整个数据变成有序序列

def quick_sort(alist,start,end):
    if start>=end: #返回条件
        return
    #设定基准值，取列表的起始元素
    mid = alist[start]
    low = start
    high = end
    #遍历序列中所有的元素和基准比较
    while low<high:
        #如果列表后面的元素(high)大于或等于基准值，high减1
        #直到找到比基准值小的元素
        while low<high and alist[high] >= mid:
            high -=1
        #把比基准小的元素放到基准值的前面
        alist[low] = alist[high]
        #如果列表前面的元素(low)比基准值小，low加1
        #直到找到比基准值大的元素
        while low<high and alist[low]<mid:
            low +=1
        #把比基准大的元素放到基准值的前面
        alist[high] = alist[low]
    alist[low] = mid
    #对基准值前面的子序列通过递归进行分区操作
    quick_sort(alist,start,low-1)
    #对基准值后面的子序列通过递归进行分区操作
    quick_sort(alist,low+1,end)

最优时间复杂度：O(nlogn) 最坏时间复杂度：O(n2) 稳定性：不稳定