七种排序算法全面比较，助你面试不慌乱

前端

2023-07-08 12:46:52

掌握七种排序算法：提升你的编程实力

在计算机科学领域，排序算法是必备技能之一。它们是用于对数据集合进行排序的一系列步骤，使数据以特定的顺序（例如，升序或降序）排列。掌握这些算法不仅在面试中至关重要，还能大大提升你的编程能力。

为什么你应该掌握七种排序算法？

面试加分项： 掌握排序算法是面试官考察应聘者算法思维和编程能力的常见问题。展示你对不同算法的理解和应用能力，将让你在众多候选者中脱颖而出。
代码优化利器： 理解排序算法的原理可以帮助你优化代码性能。根据数据集的规模和类型，不同的算法可以带来显著的性能提升。
算法思维培养： 掌握排序算法是培养算法思维的有效途径。算法思维是一种解决问题的方法，涵盖了解问题、设计解决方案和分析复杂度等关键步骤。通过学习排序算法，你可以磨练这些思维能力，并将其应用到更广泛的编程领域。

七种排序算法全面比较

1. 快速排序

时间复杂度： O(n log n)
空间复杂度： O(n log 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)

2. 归并排序

时间复杂度： O(n log n)
空间复杂度： O(n)
稳定性： 稳定
适用场景： 归并排序也是一种高效且稳定的算法，适用于大规模数据集。它使用分治策略，将数据集分解成较小的子集，然后合并排序后的子集。

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

3. 希尔排序

时间复杂度： O(n^1.3)（平均情况）
空间复杂度： O(1)
稳定性： 不稳定
适用场景： 希尔排序是一种插入排序的改进版本，适用于中等规模的数据集。它使用增量（间隔），通过对具有该增量的元素进行插入排序，逐渐缩小增量以达到排序效果。

def shell_sort(arr):
    gap = len(arr) // 2

    while gap > 0:
        for i in range(gap, len(arr)):
            temp = arr[i]
            j = i

            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap

            arr[j] = temp

        gap //= 2

4. 选择排序

时间复杂度： O(n^2)
空间复杂度： O(1)
稳定性： 不稳定
适用场景： 选择排序是一种简单直观的算法，适用于小规模数据集。它逐个查找数据集中的最小元素，并将其放置在正确的位置。

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]

5. 插入排序

时间复杂度： O(n^2)（平均情况）
空间复杂度： O(1)
稳定性： 稳定
适用场景： 插入排序也是一种简单且稳定的算法，适用于小规模数据集。它将一个元素逐个插入到已经排序的子集，直到所有元素都排序完毕。

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

6. 冒泡排序

时间复杂度： O(n^2)
空间复杂度： O(1)
稳定性： 稳定
适用场景： 冒泡排序是一种简单的算法，适用于小规模数据集。它通过不断比较相邻元素并交换位置，将最大或最小的元素逐个移动到正确的位置。

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

7. 堆排序

时间复杂度： O(n log n)
空间复杂度： O(1)
稳定性： 不稳定
适用场景： 堆排序是一种基于堆数据结构的算法，适用于大规模数据集。它将数据集构建为一个二叉堆，然后通过不断弹出堆顶元素并重新构建堆来实现排序。

def heap_sort(arr):
    def heapify(arr, n, i):
        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, n, largest)

    n = len(arr)

    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)