排序的天花板，归并排序与快速排序的巧妙切磋

2023-11-02 21:06:34

归并排序：稳定而缓慢的融合

归并排序是一种稳定且高效的排序算法，它以牺牲空间复杂度为代价，确保了算法时间复杂度的稳定性。归并排序的基本思想是将待排序数组分成两个较小的子数组，然后分别对这两个子数组进行排序，最后将排好序的子数组合并成一个排好序的数组。

归并排序的核心在于其“分而治之”的思想，它将数组不断地分解成更小的子数组，直到每个子数组只剩下一个元素为止。此时，这些子数组都是有序的，因此只需要将它们合并成一个排好序的数组即可。

快速排序：快速而灵动的天才

快速排序是一种快速而高效的排序算法，它通过将待排序数组划分为两个子数组来进行排序。快速排序的基本思想是选择一个枢轴元素，然后将数组中的元素分为两部分：一部分比枢轴元素小，另一部分比枢轴元素大。然后，分别对这两个子数组进行同样的操作，直到每个子数组只剩下一个元素为止。

快速排序的核心在于其“分而治之”的思想，它将数组不断地分解成更小的子数组，直到每个子数组只剩下一个元素为止。此时，这些子数组都是有序的，因此只需要将它们合并成一个排好序的数组即可。

比较与总结：排序的天花板之争

归并排序和快速排序都是著名的排序算法，它们各有优缺点。归并排序的时间复杂度始终为 O(n log n)，而快速排序的时间复杂度在平均情况下为 O(n log n)，但在最坏情况下为 O(n^2)。在空间复杂度方面，归并排序需要额外的空间来存储临时数组，而快速排序则不需要。

因此，在空间复杂度不重要的情况下，快速排序通常是更好的选择。但在时间复杂度很重要的情况下，归并排序是更好的选择。

实例演示：让算法活灵活现

# 归并排序
def merge_sort(array):
    if len(array) > 1:
        mid = len(array) // 2
        left_half = array[:mid]
        right_half = array[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = 0
        j = 0
        k = 0

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

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

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

# 快速排序
def quick_sort(array):
    if len(array) > 1:
        pivot = array[0]
        left = []
        right = []

        for i in range(1, len(array)):
            if array[i] < pivot:
                left.append(array[i])
            else:
                right.append(array[i])

        quick_sort(left)
        quick_sort(right)

        array[:] = left + [pivot] + right

# 测试用例
array = [10, 7, 8, 9, 1, 5]

merge_sort(array)
print("归并排序结果：", array)

quick_sort(array)
print("快速排序结果：", array)