常见八大排序算法

1 八大排序算法的时间复杂度和空间复杂度

排序算法	稳定性	平均时间复杂度	最差时间复杂度	空间复杂度	备注
堆排序	不稳定	O(nlogn)	O(nlogn)	O(1)	n大时较好
快速排序	不稳定	O(nlogn)	O(n^2)	O(nlogn)	n较大时好
希尔排序	不稳定	O(nlogn)	O(n^s)	O(1)	s时所选的分组
选择排序	不稳定	O(n^2)	O(n^2)	O(1)	n较小时较好
基数排序	稳定	O(logRB)	O(logRB)	O(n)	B是真数（0--9），R是基数
冒泡排序	稳定	O(n^2)	O(n^2)	O(1)	n小时较好
插入排序	稳定	O(n^2)	O(n^2)	O(1)	大部分已排序时较好
归并排序	稳定	O(nlogn)	O(nlogn)	O(1)	n大时较好

• 排序算法的稳定性
  假定再待排序的记录序列中，存在多个相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在序列中，A1=A2，且A1字A2之前，而在排序后的序列中，A1任在A2之前，则称这种排序算法是稳定的，否则成为不稳定的。

2 各排序算法的python实现

2.1 冒泡排序（稳定）

nums = [1,3,1,4,5,9,12,1,11,135,12,3,45,67,89,23]

def bubbleSort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0,n-i-1):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]
    return arr

bubbleSort(nums)

2.2 归并排序（稳定）

def merge(list_left,list_right):
    l,r = 0,0
    new_list = []
    while l < len(list_left) and r<len(list_right):
        if list_left[l] <= list_right[r]:
            new_list.append(list_left[l])
            l += 1
        else:
            new_list.append(list_right[r])
            r += 1
    new_list += list_left[l:]
    new_list += list_right[r:]
    return new_list

def mergeSort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr)//2
    list_left = mergeSort(arr[:mid])
    list_right = mergeSort(arr[mid:])
    return merge(list_left,list_right)

arr = [12,33,15,11,1,1334,122234]
res = mergeSort(arr)
print(res)

2.3 插入排序（稳定）

def insertSort(arr):
    for i in range(len(arr)):
        preIndex = i - 1
        current = arr[i]
        while preIndex >=0 and arr[preIndex] > current:
            arr[preIndex+1]=arr[preIndex]
            preIndex -=1
        arr[preIndex+1] = current
    return arr
nums = [1,4,7,2,5,8,3,6,9,0]
insertSort(nums)

2.4 基数排序 (稳定)

def radixSort(arr):
    n = len(str(max(arr)))
    for k in range(n):
        bucket_list = [[] for i in range(10)]
        for i in arr:
            bucket_list[i//(10**k)%10].append(i)
        arr = [j for i in bucket_list for j in i]
    return arr

2.5 选择排序 （不稳定）

算法流程：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

def selectionSort(arr):
    for i in range(len(arr)-1):
        minIndex = i # 记录最小数的索引
        for j in range(i+1,len(arr)):
            if arr[j]<arr[minIndex]:
                minIndex = j
        if i!= minIndex:
            arr[i],arr[minIndex] = arr[minIndex],arr[i]
    return arr     

nums = [1,4,7,2,5,8,3,6,9,0]
selectionSort(nums)

2.6 快速排序 （不稳定）

def quickSort(arr,i,j):
    if i >= j:
        return []
    pivot = arr[i] # 以第一个元素为基准
    low = i
    high = j
    while i < j:
        while i<j and arr[j]>=pivot:
            j -= 1
        arr[i] = arr[j]
        while i<j and arr[i] <= pivot:
            i += 1
        arr[j] = arr[i]
    arr[j] = pivot
    quickSort(arr,low,i-1)
    quickSort(arr,i+1,high)
    return arr

2.7 希尔排序

def shellSort(arr):
    n = len(arr)
    gap = int(n/2)
    while gap > 0:
        for i in range(gap,n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j-gap] > temp:
                arr[j] = arr[j-gap]
                j -= gap
            arr[j] = temp
        gap = int(gap/2)
    return arr

2.8 堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

def heapify(arr, n, i): 
    largest = i  
    l = 2 * i + 1     # left = 2*i + 1 
    r = 2 * i + 2     # right = 2*i + 2 
  
    if l < n and arr[i] < arr[l]: 
        largest = l 
  
    if r < n and arr[largest] < arr[r]: 
        largest = r 
  
    if largest != i: 
        arr[i],arr[largest] = arr[largest],arr[i]  # 交换
        # 此时largest位置的数字（也就是最开始输入那个lis[i]）处于待定状态，需要在它所有根部中确定其位置
        heapify(arr, n, largest) 
  
def heapSort(arr): 
    n = len(arr) 
  
    # Build a maxheap. 
    for i in range(n, -1, -1): 
        # 先把堆调整好小根堆的状态，在全堆中逐个调整每个数字的位置，调整的方法是在它所有根部中确定其位置
        heapify(arr, n, i) 
  
    # 一个个交换元素
    for i in range(n-1, 0, -1): 
        arr[i], arr[0] = arr[0], arr[i]   # 交换
        # 把新上来的0号安排到合适的位置上去,其中i指的是要调整的堆的范围
        heapify(arr, i, 0)