Python的十种常见算法

时间 2019-11-11

标签 python 常见算法栏目 Python 繁體版

原文原文链接

十种排序算法

1. 常见算法分类

十种常见排序算法通常分为如下几种：python

（1）非线性时间比较类排序：算法

a. 交换类排序（快速排序、冒泡排序）shell

b. 插入类排序（简单插入排序、希尔排序）数组

c. 选择类排序（简单选择排序、堆排序）app

d. 归并排序（二路归并排序、多路归并排序）less

（2）线性时间非比较类排序：函数

a. 技术排序性能

b. 基数排序ui

c. 桶排序code

总结：

（1）在比较类排序种，归并排序号称最快，其次是快速排序和堆排序，二者不相伯仲，可是有一点须要注意，数据初始排序状态对堆排序不会产生太大的影响，而快速排序却偏偏相反。

（2）线性时间非比较类排序通常要优于非线性时间比较类排序，但前者对待排序元素的要求较为严格，好比计数排序要求待待排序数的最大值不能太大，桶排序要求元素按照hash分桶后桶内元素的数量要均匀。线性时间非比计较类排序的典型特色是以空间换时间。

2. 算法描述于实现

2.1 交换类排序

交换类排序的基本方法是：两两比较待排序记录的排序码，交换不知足顺序要求的偶对，直到所有知足位置。常见的冒泡排序和快速排序就属于交换类排序。

2.1.1 冒泡排序

算法思想：

从数组中第一个数开始，依次便利数据组中的每个数，经过相邻比较交换，每一轮循环下来找出剩余未排序数终端最大数并“冒泡”至数列的顶端。

算法步骤：

（1）从数组中第一个数开始，依次与下一个数比较并次交换比本身小的数，直到最后一个数。若是发生交换，则继续下面的步骤，若是未发生交换，则数组有序，排序结束，此时时间复杂度未O(n)；

（2）每一轮“冒泡”结束后，最大的数将出如今乱序数列的最后一位。重复步骤1。

稳定性：稳定排序。

时间复杂度：O(n)至O(n^2)，平均时间复杂度为O(n^2)。

最好的状况：若是待排序数据列为正序，则一趟排序就可完成排序，排序码的比较次数为(n-1)次，且没有移动，时间复杂度为O(n)。

最坏的状况：若是待排序数据序列为逆序，则冒泡排序须要(n-1)趟起泡，每趟进行（n-i）次排序码的比较和移动，即比较和移动次数均达到最大值：

比较次数：Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n^2)

移动次数等于比较次数，所以最坏时间复杂度为O(n^2)

实例代码：

# 冒泡排序
def bubble_sort(nums):
    for i in range(len(nums)-1):    # 这个循环负责冒泡排序进行的次数
        for j in range(len(nums)-i-1): # j为列表下标
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]
    return nums

print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))
# 输出：[8, 12, 19, 22, 32, 33, 45, 97]

2.1.2 快速排序

冒泡排序是在相邻的两个记录进行比较和交换，每次交换只能上移或下移一个位置，致使总的比较与移动次数较多。快速排序又称为分区交换排序，是对冒泡排序的改进，快速排序采用的思想是分治思想。

算法原理：

（1）从待排序的n个记录中任意选取一个记录（一般选取第一个记录）为分区标准；

（2）把全部小于该排序列的记录移动到左边，把全部大于该排序码的记录移动到右边，中间放所选记录，称之为第一趟排序；

（3）而后对先后两个子序列分别重复上述过程，直到全部记录都排好序。

稳定性：不稳定排序

时间复杂度：O(nlog2n)至O(n^2)，平均时间复杂度为O(nlogn)。

最好的状况：每趟排序结束后，每次划分使两个子文件的长度大体相等，时间复杂度为O(nlogn)。

最坏的状况：使待排序记录已经拍好序，第一趟通过（n-1）次比较后第一个记录保持位置不变，并等到一个（n-1）个元素的子记录；第二趟通过（n-2）次比较，将第二个记录定位在原来的位置上，并获得一个包括（n-2）个记录的子文件，依次类推，这样总的比较次数是：

Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n2)

实例代码：

# 快速排序
def quick_sort(array):
    if len(array) < 2:  # 基线条件（中止递归的条件）
        return array
    else:   # 递归条件
        base_value = array[0]   # 选择基准值
        # 由全部小于基准值的元素组成的子数组
        less = [m for m in array[1:] if m < base_value]
        # 包括基准在内的同时和基准相等的元素
        equal = [w for w in array if w == base_value]
        # 由全部大于基准值的元素组成的子数组
        greater = [n for n in array[1:] if n > base_value]
    return quick_sort(less) + equal + quick_sort(greater)

# 示例：
array = [2,3,5,7,1,4,6,15,5,2,7,9,10,15,9,17,12]
print(quickSort(array))
# 输出为[1, 2, 2, 3, 4, 5, 5, 6, 7, 7, 9, 9, 10, 12, 15, 15, 17]

2.2 插入类排序

插入排序的基本方法是：每步将一个待排序的记录，按其排序码大小，插到前面已经排序的文件中的适当位置，直到所有插入完为止。

2.2.1 直接插入排序

原理：从待排序的第n个记录中的第二个记录开始，依次与前面的记录比较并寻找插入的位置，每次外循环结束后，将当前的数插入到合适的位置。

稳定性：稳定排序。

时间复杂度：O(n)至O(n^2)，平均时间复杂度是O(n^2)。

最好状况：当待排序记录已经有序，这时须要比较的次数是Cmin=n−1=O(n) 。

最坏状况：若是待排序记录为逆序，则最多的比较次数为。Cmax=∑i=1n−1(i)=n(n−1)2=O(n2) 。

实例代码：

# 直接插入排序
def insert_sort(array):
    n = len(array)
    for i in range(1, n):
        if array[i] < array[i - 1]:
            temp = array[i]
            index = i  # 待插入的下标
            for j in range(i - 1, -1, -1):  # 从i-1循环到0（包括0）
                if array[j] > temp:
                    array[j + 1] = array[j]
                    index = j  # 记录待插入下标
                else:
                    break
            array[index] = temp
    return array


lst = [1, 3, 4, 5, 6, 99, 56, 23, 78, 90]
print(insert_sort(lst))
# [1, 3, 4, 5, 6, 23, 56, 78, 90, 99]

2.2.2 Shell排序

Shell排序又称缩小增量排序，由D.L.Shell在1959年提出，是对直接插入排序的改进。

原理：Shell排序法是对相邻指定距离（称为增量）的元素进行比较，并不断把增量缩小至1，完成排序。

shell排序开始时增量较大，分组较多，每组的记录数目较少，故在各组内采用直接插入排序较快，后来增量di逐渐缩小，分组数减小，各组的记录数增多，但因为已经按（di-1）分组排序，文件较接近于有序状态，因此新的一趟排序过程较块。所以Shell排序在效率上比直接插入排序有较大的改进。

在直接插入排序的基础上，将直接插入排序中的1所有改变称增量d便可，由于shell排序最后一轮的增量d就为1.

稳定性：不稳定排序

时间复杂度：O(n^1.3)到O(n^2)。Shell排序算法的时间复杂度分析比较复杂，实际所需的时间取决于各次排序时增量的个数和增量的取值。研究代表，若增量的取值比较合理，Shell排序算法的时间复杂度约为O(n^1.3)。

对于增量的选择，Shell最初建议增量选择为n/2，而且对增量取半直到1；D.Knuth教授建议di+1=[di-13]序列。

def shellSort(nums):
    # 设定步长
    step = len(nums) // 2
    while step > 0:
        for i in range(step, len(nums)):
            # 相似插入排序, 当前值与指定步长以前的值比较, 符合条件则交换位置
            while i >= step and nums[i - step] > nums[i]:
                nums[i], nums[i - step] = nums[i - step], nums[i]
                i -= step
        step = step // 2
    return nums


if __name__ == '__main__':
    nums = [9, 3, 5, 8, 2, 7, 1]
    print(shellSort(nums))

2.3 选择类排序

选择类排序的基本方法是：每步从待排序记录中选出排序码最小的记录，顺序放在已排序的记录序列的后面，直到所有排完。

2.3.1 简单选择排序（又称直接选择排序）

原理：从全部记录中选出最小的一个数据元素与第一个位置的记录交换；而后再剩下的记录当中再找最小的与第二个位置的记录交换，循环到只剩下最后一个数据元素为止。

稳定性：不稳定排序。

时间复杂度：最坏、最好和平均复杂度均为O(n^2)，所以，简单选择排序也是常见排序算法中性能最差的排序算法。简单选择排序的比较次数与文件的初始状态没有关系，在第i趟排序中选出最小排序码的记录，须要作(n-i)次比较，所以总的比较次数是：∑i=1n−1(n−i)=n(n−1)/2=O(n2)。

# 简单选择排序
def selsectd_sort(array):
    # 获取list的长度
    length = len(array)
    # 进行比较的轮数
    for i in range(0, length-1):
        smallest = i    # 默认设置最小值的index为当前值
        # 用当先最小index的值分别与后面的值进行比较，以便获取最小index
        for j in range(i+1, length):
            # 若是找到比当前值小的index，则进行两值交换
            if array[j] < array[smallest]:
                array[j], array[smallest] = array[smallest], array[j]

lst = [1, 4, 5, 0, 6]
print(selsectd_sort(lst))

2.3.2 堆排序

直接选择排序中，第一次选择通过了(n-1)次比较，只是从排序码序列中选出了一个最小的排序码，而没有保存其余中间比较结果。因此后一趟排序时又要重复许多比较操做，下降了效率。J.Willioms和Floyd在1964年提出了堆排序方法，避免了这一缺点。

堆的性值：

（1）性质：彻底二叉树或者是近似彻底二叉树；

（2）分类：

大顶堆：父节点不小于子节点键值。

小顶堆：父节点不大于子节点键值，图展现一个最小堆

（3）左右孩子：没有大小的顺序

（4）堆的存储：

通常都用数组来存储堆，i节点的父节点下标就为（i - 1）/2.。

它的左右子节点下标分别为(2*i+1)和(2*i+2)。

如第0个节点左右子节点下标分别为1和2.

（5）堆的操做

a. 创建堆

>以最小堆为例，若是以数组存储元素时，一个数组具备对应的树表现形式，但树并不知足堆的条件，须要从新排列元素，能够创建“堆化”的树。

b. 插入堆

>将一个新元素插入到表尾，即数组末尾时，若是新构成的二叉树不知足堆的性质，须要从新排列元素。

c. 删除堆

堆排序中，删除一个元素老是发生在堆顶，由于堆顶的元素是最小的（小顶堆中）。表中最后一个元素用来填补空缺位置，结果树被更新以知足堆条件。

稳定性：不稳定排序

插入代码实现：

每次插入都是讲新数据放在数组最后。能够发现从这个新数据的父节点到根节点必然为一个有序的数列，如今的任务是将这个新数据插入到这个有序数据中，这就相似于直接插入排序中将一个数据并入到有序区间中，这是节点“上浮”调整。

（6）堆排序的实现

因为堆也是用数组来存储的，故堆数组进行堆化后，第一次将A[0]与A[n-1]交换，再对A[0...n-2]从新恢复堆。第二次将A[0]与A[n-2]交换，再对A[0...n-3]从新恢复堆，重复这样的操做直到A[0]与A[1]交换。因为每次都是将最小的数据并入到后面的有序区间，故操做完成后整个数组就有序了。有点相似于直接选择排序。

# 堆排序
def sift_down(array, start, end):
    """
    调整成大顶堆，初始堆时，从下往上；交换堆顶与堆尾后，从上往下调整
    :param array: 列表的引用
    :param start: 父结点
    :param end: 结束的下标
    :return: 无
    """
    while True:
        # 当列表第一个是如下标0开始，结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2;
        # 若下标以1开始，左孩子则为2*i,右孩子则为2*i+１
        left_child = 2*start + 1  # 左孩子的结点下标
        # 当结点的右孩子存在，且大于结点的左孩子时
        if left_child > end:
            break

        if left_child+1 <= end and array[left_child+1] > array[left_child]:
            left_child += 1
        if array[left_child] > array[start]:  # 当左右孩子的最大值大于父结点时，则交换
            array[left_child], array[start] = swap(array[left_child], array[start])

            start = left_child  # 交换以后以交换子结点为根的堆可能不是大顶堆，需从新调整
        else:  # 若父结点大于左右孩子，则退出循环
            break

def heap_sort(array):  # 堆排序
    # 先初始化大顶堆
    first = len(array)//2 - 1  # 最后一个有孩子的节点(//表示取整的意思)
    # 第一个结点的下标为０，不少博客&课本教材是从下标1开始，无所谓吧，你随意
    for i in range(first, -1, -1):  # 从最后一个有孩子的节点开始往上调整
        print(array[i])
        sift_down(array, i, len(array)-1)  # 初始化大顶堆

    print("初始化大顶堆结果:", array)
    # 交换堆顶与堆尾
    for head_end in range(len(array)-1, 0, -1):  # start stop step
        array[head_end], array[0] = array[0], array[head_end] # 交换堆顶与堆尾
        sift_down(array, 0, head_end-1)  # 堆长度减一(head_end-1)，再从上往下调整成大顶堆


if __name__ == "__main__":
    array = [16, 7, 3, 20, 17, 8]
    print(array)
    heap_sort(array)
    print("堆排序最终结果:", array)

（7）堆排序的性能分析

因为每次从新恢复堆的时间复杂度为O(logN)，共（N-1）次堆调整操做，再加上前面创建堆时（N/2）次向下调整，每次调整时间复杂度也为O(logN)。两次操做时间相加仍是O(NlogN)。故堆排序的时间复杂度为O(N logN)。

最坏状况：若是待排序数组是有序的，仍然须要O(N*logN)复杂度的比较操做，只是少了移动的操做；

最好状况：若是待排序数组是逆序的，不只须要O(N*logN)复杂度的比较操做，并且须要O(N*logN)复杂度的交换操做。总的时间复杂度仍是O(N*logN)。

所以，堆排序和快速排序再效率上是差很少的，可是堆排序通常优于快速排序的重要一点是，数据的初始分布状况对堆排序的效率没有大的影响。

2.4 归并排序

（1）算法思想：

归并排序属于比较类非线性时间排序，号称比较类排序中性能最佳者，再数据应用中较广。

归并排序是分治法的一个典型应用。将已有序的子序列合并，获得彻底有序的序列；即先使每一个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

（2）稳定性

稳定排序算法

（3）时间复杂度

最坏，最好和平均时间复杂度都是O(nlogn)

# 归并排序
def merge(left, right):
    # 从两个右顺序的列表李白你依次取数据比较后放入result
    # 每次咱们分别拿出两个列表中最小的数比较，把较小的放入result
    result = []
    while len(left) > 0 and len(right) > 0:
        # 为了保持稳定性，当遇到相等的时候优先把左侧的数放进结果列表
        # 由于left原本也是大数列中比较靠左的
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
        # while循环出来以后，说明其中一个数组没有数据了
        # 咱们把另外一个数组添加到结果数组后面
    result += left
    result += right
    return result

def merge_sort(array):
    # 不断递归调用本身，一直到拆分红单个元素的时候就返回这个元素，再也不拆分了
    if len(array) == 1:
        return array

    # 取拆分的中间位置
    middle = len(array) // 2
    # 拆分事后左侧子串
    array_left = array[:middle]
    # 拆分事后右侧子串
    array_right = array[middle:]

    # 对拆分事后的左右字串再拆分，一直到只有一个元素为止
    # 最后一次递归时候， left和right都会接到一个元素的列表
    # 最后一次递归以前的left和right会接收到排好序的子序列
    left = merge_sort(array_left)
    right = merge_sort(array_right)

    # 咱们对返回的两个拆分结果进行排序后合并再返回正确顺序的字列表
    # 这里咱们调用一个函数帮助咱们按顺序合并left和rigth
    return merge(left, right)

lst = [5, 4, 3, 2, 1]
print(merge_sort(lst))

2.5 线性时间非比较类排序

2.5.1 计数排序

计数排序使一个非基于比较的排序算法，该算法于1954年由Harold H.Seward提出，它的优点在于对于较小范围内的整数排序。它的复杂度为O(n+k)(其中K使待排序数的范围)，快于任何比较排序算法，缺点就是很是消耗空间。很明显，若是当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序，好比堆排序和归并排序和快速排序。

（1）算法原理

基本思想是对于给定的输入序列中的每个元素x，肯定该序列中值小于x的元素的个数。一旦有了这个信息，就能够将x直接存放到最终的输出序列的正确位置上。例如，若是输入序列中只有17个元素的值小于x的值，则x能够直接存放在输出序列的第18个位置上。固然，若是有多个元素具备相同的值时，咱们不能将这些元素放在输出序列的同一个位置上，在代码中做适当的修改便可。

（2）算法步骤：

a. 找出待排序的数组中最大的元素；

b. 统计数组中每一个值为i的元素出现的次数，存入数组c的第i项；

c. 对全部的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

d. 反向填充目标数组：将每一个元素i放在新数组的第C(i)项，每放一个元素就将 C(i)减去1。

（3）时间复杂度

O(n+k)

（4）空间复杂度

O(k)

（5）要求

待排序数中最大数值不能太大

（6）稳定性

稳定

（7）代码示例

# 计数排序
def counting_sort(a, k):  # k = max(a)
    n = len(a)  # 计算a序列的长度
    b = [0 for i in range(n)]  # 设置输出序列并初始化为0
    c = [0 for i in range(k + 1)]  # 设置计数序列并初始化为0，
    for j in a:
        c[j] = c[j] + 1
    for i in range(1, len(c)):
        c[i] = c[i] + c[i-1]
    for j in a:
        b[c[j] - 1] = j
        c[j] = c[j] - 1
    return b


print(counting_sort([1, 3, 5, 32, 423, 5, 23, 5, 75], 423))

注意：计数排序是典型的以空间换时间的排序算法，对待排序的数据有严格的要求，好比待排序的数值中包含负数，最大值都有限制，谨慎使用。

2.5.2 基数排序

基数排序属于“分配式排序”，是非比较类线性时间排序的一种，又称“桶子法”。顾名思义，它是透过键值的部分信息，将要排序的元素分配至某些“桶”中，已达到排序的做用。

# 基数排序
def radix_sort(list, d=3): # 默认三位数，若是是四位数，则d=4，以此类推
    for i in range(d):  # d轮排序
        s = [[] for k in range(10)]  # 因每一位数字都是0~9，建10个桶
        for j in list:
            s[int(j / (10 ** i)) % 10].append(j)
        re = [a for b in s for a in b]
    return re

print(radix_sort([12, 4, 23, 26, 85, 12, 45], 2))

2.5.3 桶排序

桶排序也是分配排序的一种，但其是基于比较排序的，这也是与基数排序最大的区别所在。

（1）算法思想

桶排序算法相似于散列表。首先要假设待排序的元素输入符合某种均匀分布，例如数据均匀分布在[0, 1]区间上，则可将此区间划分为10个小区间，称为桶，对散布到同一个桶中的元素再排序。

（2）要求

待排序数长度一致

（3）排序过程

a. 设置一个定量的数组看成空桶子；

b. 寻访序列，而且把记录一个一个放到对应的桶子去；

c. 对每一个不是空的桶子进行排序；

d. 从不是空的桶子里把项目再放回原来的序列中。

>例如待排序列 k = {49, 38, 35, 97, 76, 73, 27, 49}。这些数据所有在1—100之间。所以咱们定制10个桶，而后肯定映射函数 f(k) = k/10。则第一个关键字49将定位到第4个桶中（49/10=4）。依次将全部关键字所有堆入桶中，并在每一个非空的桶中进行快速排序。

（4）时间复杂度

对N个关键字进行桶排序的时间复杂度分为两个部分：

a. 循环计算每一个关键字的桶映射函数，这个时间复杂度是O(N)

b. 利用先进的比较排序算法对每一个桶内的全部数据进行排序，对于N个待排数据，M个桶，平均每一个桶[N/M]个数据，则桶内排序的时间复杂度为：∑i=1MO(Ni∗logNi)=O(N∗logNM) 。其中Ni为第i个桶的数据量。

所以，平均时间复杂度为线性的O(N+C)，C为桶内排序所花费的时间。当每一个桶只有一个数，则最好的时间复杂度为: O(N)。

# 桶排序
def bucket_sort(a):
    buckets = [0] * ((max(a) - min(a)) + 1)  # 初始化桶元素为0
    for i in range(len(a)):
        buckets[a[i] - min(a)] += 1  # 遍历数组a，在桶的相应位置累加值
    b = []
    for i in range(len(buckets)):
        if buckets[i] != 0:
            b += [i + min(a)] * buckets[i]
    return b


print(bucket_sort([1,3, 4, 53, 23, 534, 23]))