重新审视蓝桥杯筑基篇排序算法，掌握基础逻辑，挑战高阶编程

2023-11-27 18:26:57

排序算法：理解各种排序技术的艺术

简介

排序是计算机科学的基础，在各种领域都至关重要。它涉及将无序元素组织成特定顺序。蓝桥杯筑基篇介绍了六种流行的排序算法，帮助初学者掌握这些算法的原理和应用。

选择排序

选择排序是一种直接而简单的算法。它从无序序列中选择最小的元素并将其与第一个元素交换。此过程重复，直到最后一个元素排序。选择排序的平均时间复杂度为 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]

插入排序

插入排序将元素插入到前面已排序的部分中。它从第二个元素开始，并将其与之前的元素进行比较，直到找到合适的位置进行插入。插入排序的平均时间复杂度为 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

冒泡排序

冒泡排序是最直观的算法。它比较相邻元素并交换位置，使较小的元素向上移动。冒泡排序的平均时间复杂度和最坏情况时间复杂度均为 O(n^2)，空间复杂度为 O(1)。

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

快速排序

快速排序采用分而治之的方法。它选择一个枢纽元素，将序列划分为左右两个子序列，并递归地对子序列进行排序。快速排序的平均时间复杂度为 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(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_idx, right_idx = 0, 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

堆排序

堆排序利用堆数据结构。它将序列构建成一个堆，然后反复从堆中移除最大元素。堆排序的平均时间复杂度和最坏情况时间复杂度均为 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]
        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]
        heapify(arr, n, largest)