排序算法：助力优化程序，提升性能

后端

2023-12-14 04:15:35

用排序算法让数据井然有序

想象一下，你正在处理一堆杂乱无章的数据，找不到所需信息，这时，排序算法就像一把锋利的宝剑，可以将这些数据按照你想要的方式排列得井井有条。通过掌握排序算法，你可以快速找到所需信息，简化数据处理，提高编程效率。

多种排序算法，各显神通

排序算法种类繁多，每一种都有其独特的优势和劣势。选择合适的算法可以事半功倍。

选择排序： 简单易懂，适合小规模数据排序。
插入排序： 渐进排序，适合部分有序数据排序。
归并排序： 分治排序，适用于大规模数据排序。
快速排序： 快速高效，适用于平均分布的数据排序。
堆排序： 基于堆结构的排序，适用于查找最大或最小值的情况。

算法复杂度，衡量效率的标尺

算法复杂度是一个重要的衡量标准，它反映了算法在执行过程中所消耗的时间和空间资源。

时间复杂度： 算法执行所需的时间，通常使用大O符号表示。
空间复杂度： 算法执行过程中所占用的内存空间，也使用大O符号表示。

选择排序算法，简单直接

选择排序算法通过不断选择最小（或最大）的元素并将其放置在正确的位置来对数据进行排序。它的时间复杂度为O(n^2)，空间复杂度为O(1)。

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

插入排序算法，渐进优化

插入排序算法通过将每个元素逐个插入到已排序的子序列中来对数据进行排序。它的时间复杂度为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
    return arr

归并排序算法，分治征服

归并排序算法通过将数据分成更小的子序列，对子序列进行排序，然后再合并子序列来对数据进行排序。它的时间复杂度为O(n log n)，空间复杂度为O(n)。

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

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

    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)

    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

    while left_index < len(left):
        merged.append(left[left_index])
        left_index += 1

    while right_index < len(right):
        merged.append(right[right_index])
        right_index += 1

    return merged

快速排序算法，快速高效

快速排序算法通过选择一个枢轴元素，将数据分成两部分，然后对这两部分进行排序。它的时间复杂度为O(n log n)（平均情况下）或O(n^2)（最坏情况下），空间复杂度为O(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)

堆排序算法，优先队列

堆排序算法通过将数据构建成一个堆结构，然后从堆中依次取出最大或最小的元素来对数据进行排序。它的时间复杂度为O(n log n)，空间复杂度为O(1)。

def heap_sort(arr):
    n = len(arr)

    # Build a max heap.
    for i in range(n//2 - 1, -1, -1):
        heapify(arr, n, i)

    # One by one extract an element from heap and
    # place it at the end of sorted array.
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # swap
        heapify(arr, i, 0)

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]  # swap
        heapify(arr, n, largest)