常见排序算法之python实现

1. 冒泡排序

时间复杂度为O(n^2)， 稳定的排序算法

思路：一开始比较的区间是【0，n-1】，依次比较相邻两数，哪个数大哪个数就放在后面，这样一次遍历数组后，最大的数会在数组的最后一个位置，然后比较区间从【0，n-1】缩小到了【0，n-2】，在进行一次遍历下来，第二大的数会被放在数组倒数第二的位置，依次类推。直到把范围缩小到一个数的时候，数组就有序了。

def bubbleSort(arr):
    
　　length = len(arr)
    for i in range(length-1): #趟数
        for j in range(length-i-1): #每趟元素数
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

    return arr

 2. 选择排序

时间复杂度为O(n^2)，不稳定的排序算法

思路：一开始从【0，n-1】选出一个最小值放在位置0上；第二次从【1，n-1】上选择一个最小值放在位置1上；依次类推；直到数组访问剩下一个元素时，数组有序了。

def selectionSort(arr):
    """选择排序
    """
    length = len(arr)

    for i in range(length):
        min_i = i # 最小值索引
        for j in range(i, length):
            if arr[min_i] > arr[j]:
                min_i = j

        arr[min_i], arr[i] = arr[i], arr[min_i]

    return arr

3. 插入排序*

时间复杂度为O(n^2)，稳定的排序算法

注：当数组几乎有序的情况下，时间复杂度为O(n*k)，k为最多移动的距离；当数组逆序时，时间复杂度最大为O(n^2)

思路：把n个待排序的元素看成是一个有序表和一个无序表，开始时有序表只有一个元素，无序表有n-1个元素。排序过程中每次从无序表中取出一个元素，把它的排序码依次与有序表中元素比较（后->前），将它插入有序表的适当位置，使之成为新的有序表。

def insertSort(arr):
    """插入排序
    """
    length = len(arr)

    for i in range(length-1):
        o_i = i # 有序表最后一个元素索引
        u_v = arr[o_i+1] # 无序表的元素值
        
        while o_i >= 0 and arr[o_i] > u_v:
            arr[o_i+1] = arr[o_i]
            o_i -= 1
        arr[o_i+1] = u_v # 带插入元素合适位置，+1是因为前面-1

    return arr

4. 归并排序*

时间复杂度为O(nlogn)，稳定的排序算法

思路：首先让数组每一个元素成为长度为1的有序区间；然后将两个长度为1的有序区间进行合并，生成长度为2的有序区间；然后再将两个长度为2的有序区间进行合并，生成长度为4的有序区间；依次类推，直至数组有序。1合2，2合4，4合8，8合16，……。

def mergerSort(arr):
    """归并排序

        划分成左右两部分； 两两合并，成有序数组
    """
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    # 左右划分， 生成长度为1的有序数组时开始返回
    leftArr = mergerSort(arr[:mid])
    rightArr = mergerSort(arr[mid:])
    # 两两合并
    return merger(leftArr, rightArr)

def merger(left, right):
    """合并两个有序数组，形成新的有序数组返回
    """
    res = []
    l, r = 0, 0
    while l < len(left) and r < len(right):
        if left[l] <= right[r]:
            res.append(left[l])
            l += 1
        else:
            res.append(right[r])
            r += 1

    res += left[l:]
    res += right[r:]
    return res

5. 快速排序**

时间复杂度为O(nlogn), 不稳定的排序算法

注：在数组完全无序的情况下，快排效果最好，为O(nlogn)；在有序情况下效果最差，为O(n^2)。

思路：随机排序 - 在数组中随机选择一个数，使得数组中大于它的数放在它的右边、小于等于它的数放在它的左边，然后左右两边的数递归的调用快排的过程。

快排的一次划分过程　　-　　时间复杂度为O(n)：

　　首先，我们随机选择数组中的一个作为划分值；然后把划分值与数组的最后一个元素进行交换，使得划分值放到数组的最后一个位置（如b）；然后我们定义一个小于等于区间，初始时，小于等于区间为空，放在数组的最左边（如c）；然后开始遍历数组，如果元素大于划分值，继续遍历下一个元素，如果元素值小于等于划分值，就让该元素与小于等于区间的下一个元素进行交换，扩增小于等于区间（如d，e）；依次执行这个过程，直到数组中只剩一个数；然后数组最后一个数（划分值）与小于等于区间的下一个数进行交换，快排的一次划分过程就结束了（如f，g）。

　　　　 

def quickSort(arr, left, right):
    """快速排序

        对left到right区间上的数组进行快排
    """
    if left >= right:
        return None

    midValue = arr[(left+right)//2] # 划分值
    l, r = left, right
    while l < r:
        while arr[l] < midValue: l += 1
        while arr[r] > midValue: r -= 1

        if l >= r: break

        arr[l], arr[r] = arr[r], arr[l]
        r -= 1
        l += 1

    if l == r:
        l += 1
        r -= 1

    if left < r: quickSort(arr, left, r)
    if right > l: quickSort(arr, l, right)

    return None

 6. 堆排序*

时间复杂度：O(nlogn)，不稳定的排序算法，常用于查找top x

思路：首先将数组【0，n-1】区间上的所有元素构建大根堆，然后将堆顶元素与数组最后一个元素进行交换，这样数组最后一个元素为最大值，作为数组有序部分存在下来；然后将数组【0，n-2】区间上的所有元素构建大根堆，然后执行堆顶元素与数组的倒数第二个元素进行交换，这样数组后两位元素分别是数组的最大值和第二大的值存在下来；然后将数组区间【0，n-3】区间构建大根堆，交换；重复以上过程直到数组有序。

def heapSort(arr):
    """堆排序
    """
    arr = buildMaxHeap(arr)

    for i in list(range(len(arr)))[::-1]:
        arr[0], arr[i] = arr[i], arr[0]
        adjustHeap(arr, 0, i) # n表示数组的大小（不是堆）

    return arr

def buildMaxHeap(arr):
    """建立大根堆

        从下向上构建
    """
    for i in list(range(len(arr)//2))[::-1]:
        adjustHeap(arr, i, len(arr))

    return arr

def adjustHeap(arr, start, size):
    """将数组[start:]调整成堆结构

        参数
        ---
            start： int
                数组起始index
            size：int
                数组大小
    """
    lChild = 2 * start + 1
    rChild = 2 * start + 2

    maxi = start

    if maxi < size//2: # 说明有孩子
        if lChild < size and arr[lChild] > arr[maxi]:
            maxi = lChild
        if rChild < size and arr[rChild] > arr[maxi]:
            maxi = rChild

        if maxi != start: # == 说明已经是最大堆了，所以这里不是
            arr[maxi], arr[start] = arr[start], arr[maxi]
            adjustHeap(arr, maxi, size)

 7. 希尔排序

时间复杂度为O(nlogn)，不稳定的排序算法

思路：希尔排序是插入排序的改良，希尔排序相比于插入排序区别在于步长是逐步调整的，也就是希尔排序在执行完指定步长的插入排序后，逐渐调整步长，直至执行步长为1的插入排序为止。一般来说，初始步长gap=length/2，然后不断以gap=gap/2减小步长，直至降为1。希尔排序的成败和步长的选取相关，步长选取越优时间复杂度越低，步长选取越劣时间复杂度越是接近O(n^2)。

def shellSort(arr):
    """希尔排序

        使用希尔增量
    """
    n = len(arr)
    gap = n // 2 # 初始化步长
    while gap >= 1:
        for i in range(gap, n):
            index = i
            while index >= gap:
                if arr[index-gap] > arr[index]:
                    arr[index-gap], arr[index] = arr[index], arr[index-gap]
                    index -= gap
                else:
                    break

        gap //= 2 # 缩减步长
    return arr