用代码实现 6 种基本排序算法，告别茫然！

Android

2022-12-25 12:24:18

排序算法：深入浅出，轻松掌握六种基本算法

什么是排序算法？

排序算法是一种计算机算法，用于将一组数据按照特定规则组织起来。排序算法对于数据处理和管理至关重要，它们广泛应用于各种领域，例如：

数据库管理：对数据进行排序以优化查询和检索速度
搜索引擎：对搜索结果进行排序以提供最相关的结果
电子商务：对产品进行排序以根据价格、评级或其他因素进行比较
财务分析：对财务数据进行排序以识别趋势和异常值

常见的排序算法有哪些？

有许多不同的排序算法可用于处理不同的数据类型和规模。以下是六种最常见的基本排序算法：

冒泡排序 ：简单但效率较低，通过反复比较相邻元素进行排序。
插入排序 ：将新元素插入到已排序列表中适当的位置。
选择排序 ：在未排序元素中找到最小或最大值，将其放置在正确位置。
快速排序 ：使用分治法，通过选择一个枢轴值将列表分成两部分。
归并排序 ：使用分治法，通过递归将列表分成更小的子列表进行排序，然后合并结果。
希尔排序 ：一种插入排序的改进版本，通过增加元素之间的间隔进行排序。

排序算法的复杂度

排序算法的复杂度衡量算法所需的时间和空间。复杂度通常使用大 O 符号表示，如下所示：

时间复杂度 ：算法运行所需的时间，例如 O(n)、O(n²) 或 O(log n)。
空间复杂度 ：算法所需的内存量，例如 O(1)、O(n) 或 O(n²)。

基本排序算法实现

以下是六种基本排序算法的 Python 实现：

1. 冒泡排序

def bubble_sort(arr):
    """
    冒泡排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    n = len(arr)
    for i in range(n-1):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

2. 插入排序

def insertion_sort(arr):
    """
    插入排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    n = len(arr)
    for i in range(1, n):
        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

3. 选择排序

def selection_sort(arr):
    """
    选择排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

4. 快速排序

def quick_sort(arr):
    """
    快速排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    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)

5. 归并排序

def merge_sort(arr):
    """
    归并排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = merge_sort(arr[:mid])
        right_half = merge_sort(arr[mid:])
        return merge(left_half, right_half)
    else:
        return arr

def merge(left, right):
    """
    合并两个有序数组

    Args:
        left: 有序数组 1
        right: 有序数组 2

    Returns:
        合并后的有序数组
    """
    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

    merged.extend(left[left_index:])
    merged.extend(right[right_index:])

    return merged

6. 希尔排序

def shell_sort(arr):
    """
    希尔排序算法

    Args:
        arr: 待排序的数组

    Returns:
        排序后的数组
    """
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            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
    return arr