Python 算法高级篇：归并排序的优化与外部排序

引言

在计算机科学中，排序是一项基本的任务，而归并排序（ Merge Sort ）是一种著名的排序算法，它具有稳定性和良好的时间复杂度。本文将介绍归并排序的基本原理，然后深入探讨如何进行优化以及如何应用归并排序进行外部排序。

😃😄 ❤️ ❤️ ❤️

1. 归并排序的基本原理

归并排序采用分治的策略，将一个大问题分解为小问题，解决小问题，然后将它们合并以获得最终解决方案。其基本步骤如下：

• 1 . 分割（ Divide ）：将数组划分为两个子数组，通常是平均分割。
• 2 . 递归（ Conquer ）：递归地对子数组进行排序。
• 3 . 合并（ Merge ）：将排好序的子数组合并为一个有序的数组。

下面是一个简单的归并排序算法的 Python 实现：

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2  # 找到数组的中间位置
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)  # 递归排序左半部分
        merge_sort(right_half)  # 递归排序右半部分

        i = j = k = 0

        # 合并两个子数组
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

归并排序的时间复杂度是 O ( n log n )，它是一种稳定的排序算法，但它需要额外的空间来存储临时数组。

2. 归并排序的优化

尽管归并排序的时间复杂度相对较低，但它在实际应用中可能会因为空间复杂度较高而受到限制。为了解决这个问题，可以进行一些优化。

2.1 自底向上的归并排序

传统的归并排序是自顶向下的，即从顶部开始递归划分子数组。在自底向上的归并排序中，我们从底部开始，首先将相邻的元素两两合并，然后是四四合并，八八合并，直到整个数组排序完成。这样可以减少递归所需的栈空间，降低空间复杂度。

以下是自底向上归并排序的 Python 实现：

def merge_sort_bottom_up(arr):
    n = len(arr)
    curr_size = 1

    while curr_size < n:
        for left in range(0, n - 1, 2 * curr_size):
            mid = min(left + curr_size - 1, n - 1)
            right = min(left + 2 * curr_size - 1, n - 1)

            if mid < right:
                merge(arr, left, mid, right)
        curr_size *= 2

def merge(arr, left, mid, right):
    n1 = mid - left + 1
    n2 = right - mid

    L = [0] * n1
    R = [0] * n2

    for i in range(n1):
        L[i] = arr[left + i]
    for i in range(n2):
        R[i] = arr[mid + i + 1]

    i = j = 0
    k = left

    while i < n1 and j < n2:
        if L[i] <= R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1

    while i < n1:
        arr[k] = L[i]
        i += 1
        k += 1

    while j < n2:
        arr[k] = R[j]
        j += 1
        k += 1

2.2 最后优化

归并排序的一个缺点是它需要额外的空间来存储临时数组。为了避免这种情况，可以使用一个额外的数组来存储一半的数据，然后交替地将数据复制到原始数组中。这可以降低空间复杂度，但增加了一些额外的复制操作。

以下是这种优化方法的 Python 实现：

def merge_sort_optimized(arr):
    n = len(arr)
    temp_arr = [0] * n

    curr_size = 1
    while curr_size < n:
        left = 0
        while left < n - 1:
            mid = min(left + curr_size - 1, n - 1)
            right = min(left + 2 * curr_size - 1, n - 1)
            if mid < right:
                merge_optimized(arr, left, mid, right, temp_arr)
            left += 2 * curr_size
        curr_size *= 2

def merge_optimized(arr, left, mid, right, temp_arr):
    i = left
    j = mid + 1
    for k in range(left, right + 1):
        temp_arr[k] = arr[k]
    k = left
    while i <= mid and j <= right:
        if temp_arr[i] <= temp_arr[j]:
            arr[k] = temp_arr[i]
            i += 1
        else:
            arr[k] = temp_arr[j]
            j += 1
        k += 1
    while i <= mid:
        arr[k] = temp_arr[i]
        k += 1
        i += 1

这种优化方法减少了内存的使用，但增加了一些额外的复制操作。

3. 外部排序

归并排序还可以应用于外部排序，这是一种处理大规模数据集的排序方法。外部排序的主要思想是将大数据集分成多个小数据块，每个小数据块都可以在内存中进行排序。排序后，将这些小数据块合并成一个有序的大数据集。

下面是一个简单的外部排序示例，假设我们有一个非常大的文件，无法一次性加载到内存中进行排序。我们可以将文件划分为多个小文件块，分别进行排序，然后合并它们。

def external_sort(input_file, output_file, chunk_size):
    # 划分文件为多个块
    divide_file(input_file, chunk_size)

    # 对每个块进行内部排序
    sort_chunks()

    # 合并排序后的块
    merge_sorted_chunks(output_file)

def divide_file(input_file, chunk_size):
    # 从输入文件中读取数据并划分为块
    pass

def sort_chunks():
    # 对每个块进行内部排序
    pass

def merge_sorted_chunks(output_file):
    # 合并排序后的块
    pass

这个示例演示了如何将大文件划分为多个小文件块，每个块都可以在内存中排序。然后，排序后的块将被合并为一个有序的输出文件。

4. 性能比较

为了演示归并排序的不同优化版本之间的性能差异，我们可以使用一些基准测试来比较它们的运行时间。下面是一个简单的性能比较示例：

import random
import timeit

arr = [random.randint(1, 1000) for _ in range(1000)]

# 未优化的归并排序
def merge_sort_original(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort_original(left_half)
        merge_sort_original(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

# 测试未优化的归并排序的性能
original_time = timeit.timeit(lambda: merge_sort_original(arr.copy()), number=1000)

# 优化的归并排序
def merge_sort_optimized(arr):
    # 同上，省略优化后的代码

# 测试优化的归并排序的性能
optimized_time = timeit.timeit(lambda: merge_sort_optimized(arr.copy()), number=1000)

print("未优化的归并排序耗时：", original_time)
print("优化的归并排序耗时：", optimized_time)

在上述示例中，我们对未优化的归并排序和优化后的归并排序进行了性能测试。通过这种方式，你可以比较它们的性能并选择最适合你应用的版本。

5. 结论

归并排序是一种经典的排序算法，它使用分治策略和合并操作，具有稳定的性质和较低的时间复杂度。通过进行优化，例如自底向上的归并排序和减少内存使用的外部排序，我们可以提高归并排序的性能和适用性。根据应用的需求和资源限制，选择合适的排序算法版本，以获得最佳性能。这些优化方法可以在处理大数据集和内存受限的情况下发挥重要作用。

[ 专栏推荐 ]
😃 《Python 算法初阶：入门篇》😄
❤️【简介】：本课程是针对 Python 初学者设计的算法基础入门课程，涵盖算法概念、时间复杂度、空间复杂度等基础知识。通过实例演示线性搜索、二分搜索等算法，并介绍哈希表、深度优先搜索、广度优先搜索等搜索算法。此课程将为学员提供扎实的 Python 编程基础与算法入门，为解决实际问题打下坚实基础。