算法始祖，用排山倒海的力量让你穿梭排序世界！

Android

2023-10-18 23:35:31

排序算法：计算机科学的基石

排序算法是计算机科学世界中的基石，是算法之始祖，是程序员必备的武器，更是人类智慧的结晶。这些算法就像算法大师，用不同的技巧和策略征服排序难题。

排序算法的六位大师

在众多排序算法中，有六位算法大师脱颖而出：

冒泡排序： simplicité et stabilité
选择排序：élégante et performante
插入排序： intuition et efficacité
快速排序： ingénieux et rapide
希尔排序： un compromis astucieux
归并排序： puissant et équilibré

冒泡排序：简单而稳定

冒泡排序是排序算法中最简单、最容易理解的算法之一。它就像一个温柔的巨人，一遍遍地将相邻元素进行比较和交换，直到整个序列完全有序。这种简单而直观的方法，让它成为许多初学者的首选。

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

选择排序：优雅高效

选择排序则更加优雅高效。它就像一位精明的商人，总是从序列中选择出最小（或最大）的元素，然后将其交换到正确的位置。随着排序的进行，有序序列逐渐扩大，无序序列逐渐缩小，最终达到排序的目的。

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 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(nlogn)的时间复杂度完成排序。

def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 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

归并排序：强大均衡

归并排序是另一种分而治之的排序算法，以其稳定性和可靠性著称。它将序列划分为两个子序列，然后递归地对这两个子序列进行排序。最后将排好序的两个子序列合并成一个有序序列。

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
    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