【Python】十大经典排序算法

十大经典排序算法

一、介绍

排序算法按照是否在内存中进行，可以分为内部排序、及外部排序：

内部排序：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等；
外部排序：多路归并排序、基于索引的外部排序等。

按照排序方式进行区分，可以分为比较类排序、及非比较类排序：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序；
- 例如：交换排序、插入排序、选择排序、归并排序等；
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序；
- 例如：计数排序、桶排序、基数排序等。

二、算法复杂度

概念名词解释：

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

关于时间复杂度：

平方阶 (O(n2)) 排序各类简单排序：直接插入、直接选择和冒泡排序；
线性对数阶 (O(nlog2n)) 排序快速排序、堆排序和归并排序。
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序。
线性阶 (O(n)) 排序基数排序，此外还有桶、箱排序。

关于稳定性：

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

三、算法实现

1、冒泡排序（Bubble Sort）

　　冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端

1.1 算法描述

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

1.2 Python 实现

 def bubble_sort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # 标记是否发生了交换
        swapped = False
        # 最后i个元素已经有序，所以减少遍历次数
        for j in range(0, n-i-1):
            # 遍历数组从0到n-i-1
            # 交换如果发现元素大于下一个元素
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True
        # 如果在这一轮排序中没有交换发生，说明数组已经有序
        if not swapped:
            break

2、选择排序（Selection Sort）

　　选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
所以无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间

2.1 算法描述

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.2 Python 实现

 def selection_sort(arr):
    n = len(arr)
 
    # 遍历数组，找到最小元素的索引
    for i in range(n):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
 
        # 将找到的最小元素交换到当前位置
        arr[i], arr[min_index] = arr[min_index], arr[i]

3、插入排序（Insertion Sort）

　　插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

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

Python实现

 def insertion_sort(arr):
    # 从第二个元素开始遍历数组
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
 
        # 将当前元素与有序序列中的元素从后往前依次比较
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
 
        # 将当前元素插入到正确的位置
        arr[j + 1] = key

4、希尔排序（Shell Sort）

　　1959年Shell发明，第一个突破O(n2)的排序算法，又称之为递减增量排序算法。是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
　　希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

　　希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

4.1 算法描述

　　先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.3 Python 实现

 def shell_sort(arr):
    n = len(arr)
    gap = 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 //= 2

5、归并排序（Merge Sort）

　　归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并

5.1 算法描述

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
重复步骤 3 直到某一指针达到序列尾；
将另一序列剩下的所有元素直接复制到合并序列尾。

5.2 Python 实现

 def merge_sort(arr):
    # 基线条件：如果数组只有一个元素或为空，则不需要排序
    if len(arr) <= 1:
        return arr
 
    # 找到中点，将数组分成两半
    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]
 
    # 递归地对两半进行排序
    left_sorted = merge_sort(left_half)
    right_sorted = merge_sort(right_half)
 
    # 合并排序好的两半
    return merge(left_sorted, right_sorted)
 
def merge(left, right):
    sorted_arr = []
    left_index, right_index = 0, 0
 
    # 合并过程：从左和右数组中选择较小的元素添加到sorted_arr
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            sorted_arr.append(left[left_index])
            left_index += 1
        else:
            sorted_arr.append(right[right_index])
            right_index += 1
 
    # 如果左数组还有剩余，将它们添加到sorted_arr
    while left_index < len(left):
        sorted_arr.append(left[left_index])
        left_index += 1
 
    # 如果右数组还有剩余，将它们添加到sorted_arr
    while right_index < len(right):
        sorted_arr.append(right[right_index])
        right_index += 1
 
    return sorted_arr

6、快速排序（Quick Sort）

　　快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

　　快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 Python 实现

 def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        # 选择基准值，这里选择数组中的第一个元素
        pivot = arr[0]
        # 定义两个列表来存储比基准值小的和大的元素
        less = [x for x in arr[1:] if x <= pivot]
        greater = [x for x in arr[1:] if x > pivot]
 
        # 递归地对子数组进行快速排序，并与基准值合并
        return quick_sort(less) + [pivot] + quick_sort(greater)

7、堆排序（Heap Sort）

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

　　堆排序比较和交换次数比快速排序多，所以平均而言比快速排序慢，也就是常数因子比快速排序大，如果你需要的是“排序”，那么绝大多数场合都应该用快速排序而不是其它的O(nlogn)算法。

　　但是在求第k大的数或者topK等，堆排序可以在N个元素中找到top K，时间复杂度是O(N log K)，空间复杂的是O(K)，而快速排序的空间复杂度是O(N)，也就是说，如果你要在很多元素中找很少几个top K的元素，或者在一个巨大的数据流里找到top K，快速排序是不合适的，堆排序更省地方。还有就是优先级队列中，需要在一组不停更新的数据中不停地找最大/小元素。
　　分为两种方法：

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

7.1 算法描述

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 Python 实现

 def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
 
    # 检查左子节点是否存在，并且是否大于当前节点
    if left < n and arr[i] < arr[left]:
        largest = left
 
    # 检查右子节点是否存在，并且是否大于最大的节点
    if right < n and arr[largest] < arr[right]:
        largest = right
 
    # 如果找到更大的节点，交换它与当前节点，并继续堆化
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)
 
def heap_sort(arr):
    n = len(arr)
 
    # 建堆过程，从最后一个非叶子节点开始调整
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
 
    # 排序过程，每次交换第一个元素（最大元素）和最后一个元素
    # 然后重新堆化，重复直到数组完全排序
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

8、计数排序（Counting Sort）

　　计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数

8.1 算法描述

找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 Python实现

 def counting_sort(arr):
    # 找出数组中的最大值和最小值
    max_val = max(arr)
    min_val = min(arr)
 
    # 计算范围
    range_of_elements = max_val - min_val + 1
 
    # 创建计数数组，长度为范围+1，初始化为0
    count_arr = [0] * range_of_elements
 
    # 计算每个元素出现的次数
    for i in range(len(arr)):
        count_arr[arr[i] - min_val] += 1
 
    # 重新构建排序后的数组
    sorted_index = 0
    for i in range(len(count_arr)):
        while count_arr[i] > 0:
            arr[sorted_index] = i + min_val
            sorted_index += 1
            count_arr[i] -= 1
 
    return arr

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

在额外空间充足的情况下，尽量增大桶的数量
使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要

9.1 算法描述

设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。

9.2 Python 实现

 def bucket_sort(arr):
    # 找出最大值和最小值
    max_val = max(arr)
    min_val = min(arr)
 
    # 计算桶的数量，这里简单地取最大值和最小值之差再加1
    bucket_range = (max_val - min_val) // (len(arr) - 1) + 1
    buckets = [[] for _ in range(bucket_range)]
 
    # 将元素分配到各个桶中
    for i in arr:
        index = (i - min_val) // bucket_range
        buckets[index].append(i)
 
    # 对每个桶进行排序，这里使用Python内置的排序方法
    for i in range(len(buckets)):
        buckets[i].sort()
 
    # 合并桶中的元素
    sorted_arr = []
    for bucket in buckets:
        sorted_arr.extend(bucket)
 
    return sorted_arr

10、基数排序（Radix Sort）

　　基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数

10.1 算法描述

取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）

10.2 Python 实现

 def radix_sort(arr):
    max_digit = max(arr)
    place = 1
    while max_digit // place > 0:
        # 对每一位进行排序
        place *= 10
        counting_sort(arr, place)
 
def counting_sort(arr, place):
    """计数排序的变种，用于基数排序中的每一轮排序"""
    n = len(arr)
    output = [0] * n
    count = [0] * 10
 
    # 统计每个数字的个数
    for i in range(n):
        index = arr[i] // place
        count[index % 10] += 1
 
    # 将count数组转换成实际的位置
    for i in range(1, 10):
        count[i] += count[i - 1]
 
    # 构建输出数组
    i = n - 1
    while i >= 0:
        index = arr[i] // place
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1
 
    # 将排序好的数组复制回原数组
    for i in range(n):
        arr[i] = output[i]

原文参考链接：
https://www.cnblogs.com/lyq-biu/p/11359070.html
https://www.cnblogs.com/onepixel/p/7674659.html
https://www.cnblogs.com/wuxinyan/p/8615127.html

以上内容仅为个人学习记录使用。
如有转载，请附有原文出处链接。

posted on 2024-07-09 14:45 Hy旧人伤阅读(248) 评论(0) 编辑收藏举报