洞悉排序算法世界：探索下篇的精妙之境

2023-09-01 08:20:04

一、插入排序：稳步递增的优雅

插入排序就如其名，它的精髓就在于“插入”二字。它依次考察元素，将其插入到前面的正确位置，就像有序地排队一样。

思想精髓：
- 从第二个元素开始，依次遍历整个数组。
- 将当前元素与已排序的子数组中的每个元素比较，找到合适的插入位置。
- 将当前元素插入到该位置，保持子数组的顺序。

实现方式：

def insertion_sort(arr):
    for i in range(1, len(arr)):
        current_element = arr[i]
        j = i - 1
        while j >= 0 and current_element < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = current_element

特点：
- 时间复杂度：平均情况下为O(n^2)，最坏情况下为O(n^2)。
- 空间复杂度：O(1)，不需要额外空间。
- 稳定性：稳定。

二、归并排序：分而治之的智慧

归并排序是一个经典的排序算法，采用分而治之的思想，将其分解成更小的子问题解决。

思想精髓：
- 将待排序数组分成更小的子数组，不断递归。
- 在每个子数组中，将元素两两比较，归并出有序的子数组。
- 将有序的子数组合并，得到最终有序的数组。

实现方式：

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

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

    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)
- 稳定性：稳定。

三、快速排序：高效灵活的利器

快速排序是另一个十分常用的排序算法，其快速高效的特点使其在现实世界中颇受欢迎。

思想精髓：
- 选择一个基准元素，将数组分割成两部分。
- 将比基准元素小的元素放在左边，将比基准元素大的元素放在右边。
- 递归地对两个子数组进行快速排序。

实现方式：

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)