排序算法比较

排序算法比较

比较排序和非比较排序

​ 常见的排序算法都是比较排序，非比较排序包括计数排序、桶排序和基数排序，非比较排序对数据有要求，因为数据本身包含了定位特征，所有才能不通过比较来确定元素的位置。

​ 比较排序的时间复杂度通常为O(n2)或者O(nlogn)，比较排序的时间复杂度下界就是O(nlogn)，而非比较排序的时间复杂度可以达到O(n)，但是都需要额外的空间开销。

​ 比较排序时间复杂度为O(nlogn)的证明：

​ a1,a2,a3……an序列的所有排序有n!种，所以满足要求的排序a1',a2',a3'……an'（其中a1'<=a2'<=a3'……<=an'）的概率为1/n!。基于输入元素的比较排序，每一次比较的返回不是0就是1，这恰好可以作为决策树的一个决策将一个事件分成两个分支。比如冒泡排序时通过比较a1和a2两个数的大小可以把序列分成a1,a2……an与a2,a1……an（气泡a2上升一个身位）两种不同的结果，因此比较排序也可以构造决策树。根节点代表原始序列a1,a2,a3……an，所有叶子节点都是这个序列的重排（共有n!个，其中有一个就是我们排序的结果a1',a2',a3'……an'）。如果每次比较的结果都是等概率的话（恰好划分为概率空间相等的两个事件），那么二叉树就是高度平衡的，深度至少是log(n!)。

​ 又因为

1. n! < nn ,两边取对数就得到log(n!)<nlog(n)，所以log(n!) = O(nlogn).

2. n!=n(n-1)(n-2)(n-3)…1 > (n/2)^(n/2) 两边取对数得到 log(n!) > (n/2)log(n/2) = Ω(nlogn)，所以 log(n!) = Ω(nlogn)。

​ 因此log(n!)的增长速度与 nlogn 相同,即 log(n!)=Θ(nlogn)，这就是通用排序算法的最低时间复杂度O(nlogn)的依据。

---

1. 稳定排序和非稳定排序

   简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就
   说这种排序方法是稳定的。反之，就是非稳定的。
   比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，
   则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,
   a2,a3,a5就不是稳定的了。

2. 内排序和外排序

   在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；
   在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

   	平均情况	最好情况	最坏情况
   归并排序	O(nlogn)	O(nlogn)	O(nlogn)
   基数排序	O(n)	O(n)	O(n)
   快速排序	O(nlogn)	O(nlogn)	O(n2)
   希尔排序	O(n1.5)	O(n)	O(n1.5)
   插入排序	O(n2)	O(n)	O(n2)
   选择排序	O(n2)	O(n2)	O(n2)

排序的稳定性和复杂度

​ 不稳定：

• 选择排序（selection sort）— O(n2)
• 快速排序（quicksort）— O(nlogn) 平均时间, O(n2) 最坏情况; 对于大的、乱序串列一般认为是最快的已知排序
• 堆排序 （heapsort）— O(nlogn
• 希尔排序 （shell sort）— O(nlogn)
• 基数排序（radix sort）— O(n·k); 需要 O(n) 额外存储空间 （K为特征个数）

稳定：

• 插入排序（insertion sort）— O(n2)

• 冒泡排序（bubble sort） — O(n2)

• 归并排序 （merge sort）— O(n log n); 需要 O(n) 额外存储空间

• 二叉树排序（Binary tree sort） — O(nlogn); 需要 O(n) 额外存储空间

• 计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外存储空间，k为序列中Max-Min+1

• 桶排序 （bucket sort）— O(n); 需要 O(k) 额外存储空间

代码参考

#_*_coding:utf-8_*_

import random
#选择排序递归实现
def sel_sort_rec(list,n):
    if n == 0:
        return
    max_j = n
    for j in range(n):
        if list[j] > list[max_j]:
            max_j = j
    list[n], list[max_j] = list[max_j], list[n]
    sel_sort_rec(list,n-1)

#选择排序循环实现
def sel_sort(list):
    for i in range(len(list)):
        min_j = i
        for j in range(i+1,len(list)):
            if list[min_j] > list[j]:
                min_j = j
        list[min_j], list[j] = list[min_j], list[j]

#插入排序递归实现
def ins_sort_rec(list,n):
    if n == 0:
        return
    ins_sort_rec(list,n-1)
    j = n
    while j > 0 and list[j-1] >list[j]:
        list[j-1], list[j] = list[j], list[j-1]
        j -= 1


#插入排序循环实现
def ins_sort(list):
    for i in range(1,len(list)):
        j = i
        while j > 0 and list[j-1] > list[j]:
            list[j-1], list[j] = list[j], list[j-1]
            j -= 1

#递归的合并排序实现
def merge_sort(A):
    if len(A) <= 1:
        return A
    middle = len(A) // 2
    leftA = A[:middle]
    rightA = A[middle:]
    leftA_sorted = merge_sort(leftA)
    rightA_sorted = merge_sort(rightA)
    return merge(leftA_sorted,rightA_sorted)

#合并两个已经排序的序列
def merge(left, right):
    i, j = 0, 0
    alist = []
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            alist.append(left[i])
            i += 1
        else:
            alist.append(right[j])
            j += 1
    while i < len(left):   #左边剩余数据处理
        alist.append(left[i])
        i += 1
    while j < len(right):  #右边剩余数据处理
        alist.append(right[j])
        j += 1
    return alist




def main():
    list = [random.randint(1,10) for x in range(10)]
    sel_sort_rec(list,9)
    print("选择排序递归实现："+str(list))
    sel_sort(list)
    print("选择排序循环实现："+str(list))
    merge_sort(list)
    print("合并排序实现结果："+str(list))


if __name__ == '__main__':
    main()

参考链接