庖丁解牛——4种 Python 排序算法

闲谈

2023-11-18 09:03:43

算法的本质

算法，是解决特定问题的一系列步骤。它本质上是一种数学模型，规定了解决问题的详细方法和步骤。在计算机领域，算法就是计算机完成特定任务的指令集。例如，在编写代码时，算法就是我们制定的步骤，用来解决特定的问题。

排序算法的定义和特点

排序算法是一种将数据集合中的元素按某种顺序排列的算法。它具有以下几个特点：

输入：一个无序的数据集合。
输出：一个有序的数据集合。
顺序：排序算法将数据集合中的元素按某种顺序排列，如升序或降序。
稳定性：稳定排序算法保证元素在排序前后的相对顺序不变，即相等的元素在排序前后仍然相邻。
时间复杂度：排序算法的时间复杂度是指算法运行所花费的时间。它通常用大 O 表示法表示，例如 O(n^2) 或 O(n log n)。
空间复杂度：排序算法的空间复杂度是指算法运行所需的空间。它通常用 O 表示法表示，例如 O(1) 或 O(n)。

四种 Python 排序算法的介绍

Python 作为一种强大的编程语言，提供了多种内置的排序算法，包括冒泡排序、选择排序、插入排序和快速排序。这些算法各有优缺点，适用于不同的场景。

冒泡排序：冒泡排序是一种简单的排序算法，它通过不断比较相邻元素，将较大的元素向后移动，较小的元素向前移动，直到整个集合有序。其时间复杂度为 O(n^2)，空间复杂度为 O(1)。
选择排序：选择排序是一种改进的冒泡排序算法，它通过不断选择最小的元素并将其放在开头，来完成排序。其时间复杂度为 O(n^2)，空间复杂度为 O(1)。
插入排序：插入排序是一种高效的排序算法，它通过将元素逐个插入到已排序的集合中来完成排序。其时间复杂度为 O(n^2)，空间复杂度为 O(1)。
快速排序：快速排序是一种分治排序算法，它通过将集合分为两个子集合，然后递归地对子集合进行排序，最后合并子集合来完成排序。其时间复杂度为 O(n log n)，空间复杂度为 O(log n)。

四种 Python 排序算法的应用场景

冒泡排序：冒泡排序是一种简单易懂的排序算法，适合于小规模的数据集合。
选择排序：选择排序比冒泡排序略快，但仍然适用于小规模的数据集合。
插入排序：插入排序适用于已经部分有序的数据集合，以及需要稳定排序的场景。
快速排序：快速排序是一种高效的排序算法，适用于大规模的数据集合，但其时间复杂度为 O(n log n)，在最坏情况下可能会退化为 O(n^2)。

四种 Python 排序算法的性能比较

下表对四种 Python 排序算法的性能进行了比较：

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	是
选择排序	O(n^2)	O(1)	否
插入排序	O(n^2)	O(1)	是
快速排序	O(n log n)	O(log n)	否

四种 Python 排序算法的代码实现

# 冒泡排序
def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

# 选择排序
def selection_sort(arr):
    for i in range(len(arr)):
        min_index = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

# 插入排序
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

# 快速排序
def quick_sort(arr, low, high):
    if low < high:
        partition_index = partition(arr, low, high)
        quick_sort(arr, low, partition_index - 1)
        quick_sort(arr, partition_index + 1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1