何时使用每种排序算法

排序算法是计算机科学中非常重要的一种基本算法。在实际开发中，我们需要根据数据量和具体场景来选择不同的排序算法。接下来将介绍常见排序算法的使用场景和特点。

冒泡排序

冒泡排序是最简单的排序算法之一，但效率较低，适用于数据量较小的情况。冒泡排序的时间复杂度为O(n^2)。

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

选择排序

选择排序的效率比冒泡排序略高，但仍未达到较高的效率。选择排序的时间复杂度也为O(n^2)。

选择排序适用于数据量较小的情况，它的特点是不占用额外的存储空间。

def selection_sort(arr):
    for i in range(len(arr) - 1):
        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]
    return arr

插入排序

插入排序是一种非常常见的排序算法，它适合于数据量较小和部分有序的情况。插入排序的时间复杂度也为O(n^2)。

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

快速排序

快速排序是一种高效的排序算法，在大多数情况下，它的时间复杂度为O(nlogn)。但在最坏情况下（数组已有序或逆序），时间复杂度达到O(n^2)。

快速排序适用于数据量较大或需要快速排序的场景。

def quick_sort(arr, left, right):
    if left >= right:
        return
    pivot = arr[left]
    i, j = left, right
    while i < j:
        while arr[j] >= pivot and i < j:
            j -= 1
        while arr[i] <= pivot and i < j:
            i += 1
        arr[i], arr[j] = arr[j], arr[i]
    arr[left], arr[i] = arr[i], arr[left]
    quick_sort(arr, left, i - 1)
    quick_sort(arr, j + 1, right)
    return arr

归并排序

归并排序是一种高效的排序算法，在所有情况下，它的时间复杂度都为O(nlogn)。

归并排序适用于数据量大，且不容许使用快速排序的场景。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    res = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

表格总结

下面是以上排序算法的时间复杂度和适用场景的总结表格。

| 排序算法 | 时间复杂度 | 适用场景 | |---------|------------|---------| | 冒泡排序 | O(n^2) | 数据量小 | | 选择排序 | O(n^2) | 数据量小 | | 插入排序 | O(n^2) | 数据量小 | | 快速排序 | O(nlogn) | 数据量大 | | 归并排序 | O(nlogn) | 数据量大 |