【Python】排序算法

【Python】排序算法

- 算法概述

1.算法分类

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。
线性时间比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

2.算法复杂度

排序方法	时间复杂度（平均）	时间复杂度（最坏）	时间复杂度（最好）	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
快速排序	O(nlog2n)	O(n^2)	O(nlog2n)	O(nlog2n)	不稳定
插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
希尔排序	O(n^1.3)	O(n^2)	O(n)	O(1)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(n+k)	稳定
桶排序	O(n+k)	O(n^2)	O(n)	O(n+k)	稳定

3.相关概念

稳定：在a=b时，如果a原本在b的前面，排序之后a仍然在b的前面。
不稳定：在a=b时，如果a原本在b的前面，排序之后a可能在b的后面。
时间复杂度：对排序数据的总操作次数。反应当n变化时，操作次数呈现什么规律。
空间复杂度：指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

- 冒泡排序

1.算法描述

比较相邻的两个元素，如果第一个大于第二个，就交换，否则不交换；
对每一对相邻元素作同样的工作，从开始第一队到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

2.动图演示

3.代码实现

def bubblesort(self, array):
    if not array:
        return []
    length = len(array)
    for i in range(length):
        for j in range(i+1, length):
            if array[i] > array[j]:
                temp = array[i]
                array[i] = array[j]
                array[j] = temp
    return array

- 快速排序

1.算法描述

从数列中跳出一个元素，称为“基准”； 重新排列数列，比基准值小的元素放到基准值前面，比基准值大的元素放到基准值后面；
这样就把数列分成两部分，对这两部分分别重复以上步骤。

2.动图演示

3.代码实现

def quicksort(self, array, start, end):
    if end <= start:
        return []
    low = start
    high = end
    key = array[start]
    while end > start:
        if array[end] > key:
            end -= 1
        else:
            array[end] = array[start]
            start += 1
            array[start] = array[end]
    array[start] = key
    self.quicksort(array, low, start)
    self.quicksort(array, start+1, high)
    return array

- 插入排序

1.算法描述

从第一个元素开始，该元素可以认为已经被排序； 取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置； 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置； 将新元素插入到该位置后；
重复步骤2~5。

2.动图演示

3.代码实现

def insertsort(self, array):
    if not array:
        return []
    length = len(array)
    for i in range(1, length):
        j = i
        key = array[i]
        while j >= 0 and array[j-1] > key:
            array[j] = array[j-1]
            j -= 1
        array[j] = key
    return array

-希尔排序

1.算法描述

插入排序的改进版，优先比较距离较远的元素，又称缩小增量排序。
分别对序列的每个子序列进行插入排序，序列增量为gap，初始gap = length/2，以后每次减半，直到增量为1。
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

2.动图演示

3.代码实现

def shell_sort(self, array):
    if not array:
        return []
    gap = len(array)
    while gap >= 1:
        gap = gap // 2
        for i in range(gap, len(array)): #从gap开始循环：gap是几，最开始排序的元素的位置就是几
            key = array[i]
            j = i
            while j >= 0 and array[j-gap] > key:
                array[j] = array[j-gap]
                j -= gap
            array[j] = key
    return array

-堆排序

1.算法描述

堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
算法思路
1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，再将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

2.动图演示

3.代码实现

'''
构建大顶堆，从最后一个堆开始，即i = len/2，直到i = 0,保证每一个堆都是大顶堆
用堆顶元素和左右元素相比较，如果堆顶元素小，则交换
如果发生交换，则以交换位置为堆顶元素，再次调整为大顶堆
'''
def buildMaxHeap(self, array, length):
    for i in range(0, length/2)[::-1]:
        self.adjustheap(array, i, length)

def adjustheap(self, array, i, length):
    left = i * 2 + 1
    right = i * 2 + 2
    max = i
    if left < length and array[left] > array[max]:
        max = left
    if right < length and array[right] > array[max]:
        max = right
    if max != i:
        array[i], array[max] = array[max], array[i]
        self.adjustheap(array, max, length)

def heapsort(self, array):
    if not array:
        return []
    length = len(array)
    self.buildMaxHeap(array, length)
    for i in range(0, length)[::-1]:
        array[0], array[i] = array[i], array[0]
        self.adjustheap(array, 0, i)
    return array

- 选择排序

1.算法描述

从未排序的数列中选出最大（小）的元素放到已排序数列的末尾，直到所有元素均排序完毕。

2.动图演示

3.代码实现

def selectsort(self, array):
    if not array:
        return []
    length = len(array)
    for i in range(length):
        min = i
        for j in range(i+1, length):
            if array[j] < array[i]:
                min = j
        if min != i:
            temp = array[i]
            array[i] = array[min]
            array[min] = temp
    return array

- 归并排序

1.算法描述

将已有的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，成为2-路归并。

2.动图演示

3.代码实现

二路归并排序
示例代码为归并排序两个已排序的序列。
定义一个新列表，分别从序列1和序列2的第一个元素开始比较，将较小的元素插入到新列表中，再将剩余元素插入到列表末尾。

def mergesort(self, array1, array2):
    if not array1:
        return array2
    elif not array2:
        return array1
    i, j = 0, 0
    len1 = len(array1)
    len2 = len(array2)
    res = []
    while i < len1 and j < len2:
        if array1[i] < array2[j]:
            res.append(array1[i])
            i += 1
            continue
        else:
            res.append(array2[j])
            j += 1
            continue
    if i != len1:
        res += array1[i:]
    else:
        res += array2[j:]
    return res

- 基数排序

1.算法描述

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。
有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

2.动图演示

3.代码实现

def radixsort(self, array, maxDigit):
    if not array:
        return []
    mod = 10
    dev = 1
    length = len(array)
    #求最大的数的位数，确定第一轮循环次数
    num = 0
    while maxDigit != 0:
        num += 1
        maxDigit = maxDigit / mod
    for i in range(num):
        #二位数组：计数排序，每次循环置空
        tempradix = [[] for i in range(10)]
        for j in range(length):
            #求确定个十百位的值
            key = (array[j] % mod) / dev
            tempradix[key].append(array[j])
        #每次基数排序后重新得到的数列
        array = []
        for k in range(10):
            array += tempradix[k]
        mod *= 10
        dev *= 10
    return array

- 计数排序

1.算法描述

计数排序不是基于比较的排序算法。
计数排序的核心是将输入的数据作为键值存储在额外开辟的空间中（字典）。
计数排序要求输入的数据必须是有确定范围的整数。
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

2.动图演示

3.代码实现

def countingsort(self, array, maxValue):
    if not array:
        return []
    bucket = {}
    length = len(array)
    for i in range(length):
        if array[i] in bucket:
            bucket[array[i]] += 1
        else:
            bucket[array[i]] = 1
    array = []
    for i in range(maxValue+1):
        if i in bucket and bucket[i] > 0:
            array.append(i)
            bucket[i] -= 1
    return array

- 桶排序

1.算法描述

桶排序是计数排序的升级版。
桶排序利用了函数的映射关系，高效与否取决于映射函数的确定。
原理：假设数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（对桶内元素排序时可使用其他排序算法），最后将桶内的元素拼接起来。

2.算法逻辑

给定需要排序的数组：78，17，39，26，72，94，21，12，23，68
这些数字在0-100上服从均匀分布。
假设有5个桶，每个桶中的元素分别为：
17，12；
21，23；
39，26；
72，68
78，94；
分别对每个桶内元素排序，再拼接起来则可以得到排序后的数列：12，17，21，23，26，39，68，72，78，94。
3.代码实现

def bucketsort(self, array, bucketsize):
    if not array:
        return []
    minValue = array[0]
    maxValue = array[0]
    length = len(array)

    #求数组的最大值和最小值
    for i in range(length):
        if array[i] < minValue:
            minValue = array[i]
        elif array[i] > maxValue:
            maxValue = array[i]

    #桶的数量（最大值-最小值）/桶容量
    bucketCount = (maxValue - minValue) / bucketsize + 1
    #桶为二维数组
    buckets = [[] for i in range(bucketCount)]
    #映射函数：将元素分配到桶内，元素所在桶的序号为：（元素-最小值）/桶容量
    for i in range(length):
        buckets[(array[i]-minValue)/bucketsize].append(array[i])

    array = []
    for i in range(len(buckets)):
        #一个桶内的元素快速排序
        buckets[i].sort()
        for j in range(len(buckets[i])):
            array.append(buckets[i][j])
    return array