排序算法速览：一文搞懂七种常用排序及其代码实现

2023-11-08 05:09:16

揭秘排序算法的奥秘：七大算法详解与应用

排序算法是计算机领域数据处理中的中流砥柱，它们的身影无处不在，从日常生活中数据的归纳整理到海量数据的处理，排序算法都扮演着举足轻重的角色。面对不同的数据规模和应用场景，选择合适的排序算法至关重要。本文将带你深入了解七种常用的排序算法，并附上相应的代码示例，助你快速掌握它们的原理和应用。

直接插入排序：简单高效的插入法

想象一下，你需要把一堆扑克牌按照点数从小到大排列。直接插入排序就像一个熟练的扑克牌手，一次只拿出一张牌，将它插入到已排序的牌组中。从第二张牌开始，算法依次比较每一张牌，如果当前牌比之前已排序的牌小，就将其移到正确的位置，并依次将前面的牌后移一位，直到找到合适的位置插入。

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

希尔排序：改进的插入排序

希尔排序是对插入排序的改进。它将数据分成若干组，按组进行插入排序。就像在沙滩上寻找贝壳，希尔排序先将贝壳按一定间隔分成若干组，然后对每组进行插入排序，逐步缩小分组间隔，最终完成排序。

def shell_sort(arr):
    gap = len(arr) // 2
    while gap > 0:
        for i in range(gap, len(arr)):
            key = arr[i]
            j = i
            while j >= gap and key < arr[j - gap]:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = key
        gap //= 2

直接选择排序：一次选出最(小)者

直接选择排序有点像举办一场比赛，每次从剩余的参赛者中选出最强的（或最弱的），将其放在前面。算法从头开始，逐个比较元素，找到最小的（或最大的）元素，并将其与当前第一个元素交换，然后继续从剩下的元素中选出最小的（或最大的），以此类推。

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]

堆排序：基于堆的数据结构

堆排序利用了堆数据结构的特性，将数据构建成一个堆，然后一次次从堆顶弹出最大（或最小）的元素。就像移除一个金字塔顶端的方块，堆排序每次将堆顶元素与最后一个元素交换，然后重新调整堆的结构，直到所有元素都被排序。

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[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

冒泡排序：逐个比较并交换

冒泡排序就像一锅沸水，不断上升的气泡会带着杂质浮到水面。算法逐个比较相邻元素，如果前一个元素比后一个元素大，就交换它们的顺序。像气泡一样，较小的元素逐渐浮到数组前面，而较大的元素沉到数组后面。

def bubble_sort(arr):
    for i in range(len(arr)):
        swapped = False
        for j in range(0, len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break

快速排序：分而治之的典范

快速排序采用分而治之的策略，将数据划分为两个子集，并分别对子集进行快速排序，最后合并两个有序的子集。就像一个指挥家挥舞着指挥棒，快速排序将数据分成不同的部分，然后逐个征服，最终完成排序。

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)

归并排序：稳定可靠的分治算法

归并排序也是一种分治算法，它将数据分成若干个子序列，分别对子序列进行归并排序，最后将有序的子序列合并为一个有序的序列。就像将两条有序的队列合并成一条有序的队列，归并排序一步步地将小的有序序列合并成更大的有序序列，直到完成排序。

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):
    merged = []
    left_idx = 0
    right_idx = 0
    while left_idx < len(left) and right_idx < len(right):
        if left[left_idx] <= right[right_idx]:
            merged.append(left[left_idx])
            left_idx += 1
        else:
            merged.append(right[right_idx])
            right_idx += 1
    merged.extend(left[left_idx:])
    merged.extend(right[right_idx:])
    return merged