细数吴军《硅谷来信》中的排序算法

2024-02-20 11:16:24

排序算法的全面指南：快速上手冒泡、插入、快速、归并和堆排序

排序算法是计算机科学中的基石，它们能够以有效的方式对数据进行组织和排列。本文将深入探讨五种常用的排序算法：冒泡排序、插入排序、快速排序、归并排序和堆排序。深入了解它们的原理、优点和局限性，从而为各种应用选择最佳算法。

冒泡排序：简单易懂，但效率有限

冒泡排序是一种简单直观的算法，通过反复比较相邻元素并交换顺序，直至列表中所有元素按顺序排列。它的优点在于实现简单，但时间复杂度为 O(n^2)，随着数据量的增加，效率会显着下降。

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

    return arr

插入排序：渐进排序，时间复杂度更低

插入排序是一种渐进式算法，它通过将每个元素逐个插入到正确位置来对列表进行排序。与冒泡排序相比，它在近乎有序的数据上具有更好的效率，时间复杂度为 O(n^2) 的最佳情况和 O(n^2) 的最差情况。

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

    return arr

快速排序：高效的分而治之算法

快速排序是一种分而治之算法，它通过将列表划分为较小的子列表并递归地对它们排序来工作。它以一个枢纽元素为基准，将列表分成小于枢纽的元素和大于枢纽的元素，然后递归地对这两个子列表进行排序。快速排序的时间复杂度为 O(n log n) 的平均情况和 O(n^2) 的最差情况，但它通常比冒泡排序和插入排序快得多。

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

归并排序：稳定高效，时间复杂度较低

归并排序也是一种分而治之算法，它通过将列表分成较小的子列表并递归地对它们排序来工作。它将子列表合并为一个有序的列表，以获得最终的排序列表。归并排序的时间复杂度为 O(n log n) 的所有情况，使其成为大型数据集排序的高效选择。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]

    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)

    return merge(left_half, right_half)

def merge(left, right):
    merged = []
    left_index = 0
    right_index = 0

    while left_index < len(left) and right_index < len(right):
        if left[left_index] <= right[right_index]:
            merged.append(left[left_index])
            left_index += 1
        else:
            merged.append(right[right_index])
            right_index += 1

    merged.extend(left[left_index:])
    merged.extend(right[right_index:])

    return merged

堆排序：基于堆的数据结构，效率与快速排序相当

堆排序是一种基于堆的数据结构的排序算法。它通过将列表表示为一个最大堆，并重复删除堆顶元素来工作。与快速排序类似，堆排序的时间复杂度为 O(n log n) 的平均情况和 O(n^2) 的最差情况，但它通常比快速排序更快，特别是对于大型数据集。

def heap_sort(arr):
    # Build a max heap.
    for i in range(len(arr) // 2 - 1, -1, -1):
        heapify(arr, i, len(arr))

    # Sort the heap.
    for i in range(len(arr) - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, 0, i)

    return arr

def heapify(arr, i, n):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2

    if left < n and arr[left] > arr[largest]:
        largest = left

    if right < n and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, largest, n)