探索排序算法的奇妙世界

KH.

已于 2023-12-01 17:35:02 修改

阅读量1.4k

点赞数 18

文章标签：排序算法算法数据结构

于 2023-12-01 17:27:46 首次发布

本文链接：https://blog.csdn.net/weixin_42559561/article/details/134740211

版权

在计算机科学的领域中，排序算法扮演着至关重要的角色。排序是一项基础而常见的任务，而不同的排序算法在处理各种情况下展现出截然不同的性能。本文将深入研究几种经典的排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序、计数排序、桶排序和基数排序。

冒泡排序（Bubble Sort）

介绍

冒泡排序是一种简单直观的比较排序算法。它通过多次遍历数组，比较相邻元素的大小，并在必要时交换它们的位置，以达到将最大（或最小）的元素逐步冒泡到数组的末尾（或开头）的目的。冒泡排序是一种基础的排序算法，虽然在大规模数据集上性能较差，但它易于理解和实现。

算法步骤

从数组的起始位置开始，依次比较相邻的两个元素。
如果顺序不正确（前一个元素大于后一个元素），则交换它们。
继续比较和交换，直到到达数组的末尾。
重复上述步骤，每次遍历都会将最大的元素冒泡到末尾。
重复这个过程，每次都减少一个元素的遍历范围，直到整个序列有序。

Python 代码示例

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

    # 遍历所有数组元素
    for i in range(n):
        # 最后 i 个元素已经有序，不需要再比较
        for j in range(0, n-i-1):
            # 如果元素的顺序不对，交换它们
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("冒泡排序结果:", arr)

特点

简单直观： 冒泡排序的实现非常简单，易于理解。
稳定性： 冒泡排序是一种稳定的排序算法，相同元素的相对位置不会改变。
原地排序： 冒泡排序是一种原地排序算法，不需要额外的内存空间。
时间复杂度： 最坏情况下的时间复杂度为O(n^{2)，平均情况下也为O(n}2)。

适用场景

冒泡排序适用于数据量较小、或者待排序数据基本有序的情况。在大规模数据集上性能相对较差，通常不作为首选排序算法。

选择排序（Selection Sort）

介绍

选择排序是一种简单直观的比较排序算法。它通过不断选择未排序部分的最小元素，并将其放置在已排序部分的末尾，逐步完成整个数组的排序。尽管选择排序在大规模数据集上性能较差，但由于其思想简单，容易实现，因此在某些情况下仍然有其用武之地。

算法步骤

在未排序部分找到最小元素。
将最小元素交换到已排序部分的末尾。
将已排序部分的末尾标记为已排序，继续从未排序部分重复上述步骤。
重复这个过程，直到整个数组有序。

Python 代码示例

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

    # 遍历整个数组
    for i in range(n):
        # 假设当前索引的元素是最小的
        min_index = i

        # 在未排序部分找到最小元素的索引
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j

        # 将最小元素与当前位置交换
        arr[i], arr[min_index] = arr[min_index], arr[i]

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
selection_sort(arr)
print("选择排序结果:", arr)

特点

简单直观： 选择排序的实现非常简单，易于理解。
不稳定性： 选择排序是一种不稳定的排序算法，相同元素的相对位置可能会改变。
原地排序： 选择排序是一种原地排序算法，不需要额外的内存空间。
时间复杂度： 不论输入数据的分布如何，时间复杂度始终为O(n^2)。

适用场景

选择排序适用于数据量较小的情况，且在不关心排序稳定性的情况下。由于其时间复杂度相对较高，通常不适用于大规模数据集。

插入排序（Insertion Sort）

介绍

插入排序是一种简单直观的排序算法。它通过构建有序序列，对未排序的元素逐个进行插入，最终完成整个数组的排序。插入排序在小规模数据集或已经基本有序的情况下表现良好，是一种稳定的排序算法。

算法步骤

从第一个元素开始，该元素被认为是已排序的。
取出下一个元素，在已排序的序列中从后向前扫描。
如果已排序的元素大于新元素，则将已排序元素移到下一个位置。
重复步骤3，直到找到已排序的元素小于或等于新元素的位置。
将新元素插入到找到的位置。
重复上述步骤，直到整个数组有序。

Python 代码示例

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

    # 遍历整个数组
    for i in range(1, n):
        key = arr[i]
        j = i - 1

        # 将大于key的元素都向后移动一位
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1

        # 插入key到正确的位置
        arr[j + 1] = key

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
insertion_sort(arr)
print("插入排序结果:", arr)

特点

简单直观： 插入排序的实现非常简单，易于理解。
稳定性： 插入排序是一种稳定的排序算法，相同元素的相对位置不会改变。
原地排序： 插入排序是一种原地排序算法，不需要额外的内存空间。
时间复杂度： 最坏情况下的时间复杂度为O(n^{2)，平均情况下为O(n}2)。

适用场景

插入排序适用于小规模数据集或者已经基本有序的情况。在这些情况下，插入排序的性能优于其他复杂度更低的算法。

归并排序（Merge Sort）

介绍

归并排序是一种高效且稳定的排序算法，它采用分治策略，将待排序数组分成两个子数组，分别进行排序，然后将排好序的子数组合并为一个整体有序数组。归并排序的主要思想是分而治之，是一种典型的分治算法。

算法步骤

分解（Divide）： 将数组分解成两个子数组，递归地对子数组进行归并排序。
合并（Merge）： 将排好序的子数组合并成一个有序数组。
递归执行（Recursively）： 重复上述两个步骤，直到每个子数组都排好序。

Python 代码示例

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        # 递归地对左右两半进行归并排序
        merge_sort(left_half)
        merge_sort(right_half)

        # 合并两个有序子数组
        merge(arr, left_half, right_half)

def merge(arr, left, right):
    i = j = k = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            arr[k] = left[i]
            i += 1
        else:
            arr[k] = right[j]
            j += 1
        k += 1

    # 处理剩余的元素
    while i < len(left):
        arr[k] = left[i]
        i += 1
        k += 1

    while j < len(right):
        arr[k] = right[j]
        j += 1
        k += 1

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
merge_sort(arr)
print("归并排序结果:", arr)

特点

高效稳定： 归并排序是一种高效且稳定的排序算法。
分治思想： 采用分治思想，递归地将问题拆解成子问题。
原地排序： 归并排序通常不是原地排序，需要额外的空间。
时间复杂度： 归并排序的时间复杂度始终为O(n log n)。

适用场景

归并排序适用于任何规模的数据集，特别在对稳定性有要求的场景中。尤其适用于链表结构。

快速排序（Quick Sort）

介绍

快速排序是一种高效的、原地的、分治的排序算法。它基于将数组分为较小和较大两个子数组，然后递归地对子数组进行排序。快速排序是一种典型的分而治之算法，其性能通常比其他排序算法更好。

算法步骤

选择枢轴（Pivot）： 从数组中选择一个元素作为枢轴。
划分（Partition）： 将数组分为两个子数组，小于枢轴的在左边，大于枢轴的在右边。
递归排序： 递归地对左右两个子数组进行快速排序。
合并： 由于是原地排序，不需要实际的合并操作。

Python 代码示例

def quick_sort(arr, low, high):
    if low < high:
        # 找到枢轴的正确位置
        pivot_index = partition(arr, low, high)

        # 递归地对枢轴两侧进行快速排序
        quick_sort(arr, low, pivot_index)
        quick_sort(arr, pivot_index + 1, high)

def partition(arr, low, high):
    # 选择枢轴
    pivot = arr[low]

    # 划分数组
    left = low + 1
    right = high

    done = False
    while not done:
        # 在左侧找到大于枢轴的元素
        while left <= right and arr[left] <= pivot:
            left += 1

        # 在右侧找到小于枢轴的元素
        while arr[right] >= pivot and right >= left:
            right -= 1

        # 如果左侧索引小于右侧索引，交换元素
        if right < left:
            done = True
        else:
            arr[left], arr[right] = arr[right], arr[left]

    # 将枢轴放到正确的位置
    arr[low], arr[right] = arr[right], arr[low]
    return right

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
quick_sort(arr, 0, len(arr) - 1)
print("快速排序结果:", arr)

特点

高效原地排序： 快速排序是一种高效的原地排序算法。
分治思想： 采用分治思想，递归地将问题拆解成子问题。
不稳定性： 快速排序是一种不稳定的排序算法，相同元素的相对位置可能会改变。
时间复杂度： 平均情况下的时间复杂度为O(n log n)。

适用场景

快速排序适用于大规模数据集，尤其在对时间性能要求较高的场景中。由于其原地排序特性，也在对空间有限的情况下表现优异。

堆排序（Heap Sort）

介绍

堆排序是一种原地且高效的排序算法，基于二叉堆的数据结构。它将待排序的数组构建成一个二叉堆，然后逐步将堆顶元素（最大或最小）与数组末尾元素交换，并调整堆，重复这个过程直到整个数组有序。堆排序是一种选择排序，常用于大规模数据集。

算法步骤

构建最大堆（或最小堆）： 将数组转化为二叉堆结构。
堆排序： 逐步将堆顶元素与数组末尾元素交换，并调整堆，重复直到整个数组有序。

Python 代码示例

def heap_sort(arr):
    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[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)

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
heap_sort(arr)
print("堆排序结果:", arr)

特点

原地排序： 堆排序是一种原地排序算法。
不稳定性： 堆排序是一种不稳定的排序算法，相同元素的相对位置可能会改变。
时间复杂度： 堆排序的时间复杂度为O(n log n)。

适用场景

堆排序适用于大规模数据集，尤其在对时间性能要求较高的场景中。由于其原地排序特性，也在对空间有限的情况下表现优异。

希尔排序（Shell Sort）

介绍

希尔排序是一种插入排序的改进版本，也被称为缩小增量排序。它通过将待排序数组按一定步长分组，对每组进行插入排序，然后逐步缩小步长，重复这个过程，直到步长为1，最终完成整个数组的排序。希尔排序在大规模数据集上相对较快，是一种不稳定的排序算法。

算法步骤

选择步长序列： 选择一个步长序列，逐步缩小步长。
分组插入排序： 对每个步长下的分组进行插入排序。
逐步缩小步长： 重复上述步骤，直到步长为1。

Python 代码示例

def shell_sort(arr):
    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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
shell_sort(arr)
print("希尔排序结果:", arr)

特点

改进插入排序： 希尔排序是插入排序的改进版本。
不稳定性： 希尔排序是一种不稳定的排序算法，相同元素的相对位置可能会改变。
时间复杂度： 希尔排序的时间复杂度取决于步长序列的选择。

适用场景

希尔排序适用于中等规模的数据集，特别适用于对插入排序性能较差的场景。由于其步长的选择可以灵活调整，适用于不同类型的数据集。

计数排序（Counting Sort）

介绍

计数排序是一种非比较性的整数排序算法，其核心思想是通过统计数组中每个元素的出现次数，然后根据这些统计信息重建有序序列。计数排序适用于一定范围内的整数排序，但对于整数的取值范围较大时可能不太适用。

算法步骤

统计元素出现次数： 统计数组中每个元素的出现次数。
累计次数： 根据统计信息，计算每个元素在有序序列中的位置。
重建有序序列： 根据累计次数将元素放置到有序序列中。

Python 代码示例

def counting_sort(arr):
    max_value = max(arr)
    min_value = min(arr)
    range_of_elements = max_value - min_value + 1

    # 初始化计数数组和输出数组
    count = [0] * range_of_elements
    output = [0] * len(arr)

    # 统计元素出现次数
    for i in range(len(arr)):
        count[arr[i] - min_value] += 1

    # 计算累计次数
    for i in range(1, range_of_elements):
        count[i] += count[i - 1]

    # 重建有序序列
    for i in range(len(arr) - 1, -1, -1):
        output[count[arr[i] - min_value] - 1] = arr[i]
        count[arr[i] - min_value] -= 1

    # 将有序序列复制回原始数组
    for i in range(len(arr)):
        arr[i] = output[i]

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
counting_sort(arr)
print("计数排序结果:", arr)

特点

非比较性： 计数排序是一种非比较性的排序算法。
稳定性： 计数排序是一种稳定的排序算法，相同元素的相对位置不会改变。
时间复杂度： 计数排序的时间复杂度为O(n + k)，其中n是数组长度，k是整数的取值范围。

适用场景

计数排序适用于一定范围内的整数排序，尤其在整数的取值范围相对较小的情况下表现优异。

桶排序（Bucket Sort）

介绍

桶排序是一种排序算法，它通过将数组分割成若干个桶，将元素分布到不同的桶中，然后分别对每个桶中的元素进行排序，最后将所有桶中的元素按顺序合并，得到有序序列。桶排序适用于元素分布较均匀的情况，对于大规模数据集的排序效果较好。

算法步骤

将元素分配到桶中： 根据元素值的分布将元素分配到不同的桶中。
对每个桶进行排序： 对每个桶中的元素进行排序，可以选择不同的排序算法。
合并有序桶： 将每个桶中的元素按顺序合并。

Python 代码示例

def bucket_sort(arr):
    # 初始化桶的数量，这里假设为10
    num_buckets = 10
    buckets = [[] for _ in range(num_buckets)]

    # 将元素分配到桶中
    for num in arr:
        index = num * num_buckets // (max(arr) + 1)
        buckets[index].append(num)

    # 对每个桶进行排序，这里使用插入排序
    for i in range(num_buckets):
        buckets[i] = sorted(buckets[i])

    # 合并有序桶
    k = 0
    for i in range(num_buckets):
        for num in buckets[i]:
            arr[k] = num
            k += 1

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
bucket_sort(arr)
print("桶排序结果:", arr)

特点

分布式排序： 桶排序是一种分布式排序算法。
稳定性： 桶排序可以是稳定的，取决于桶内排序算法的选择。
时间复杂度： 桶排序的时间复杂度取决于桶的数量和桶内排序算法的性能。

适用场景

桶排序适用于元素分布较均匀的情况，对于大规模数据集的排序效果较好。在分布较均匀的情况下，桶排序的性能可能超过其他排序算法。

基数排序（Radix Sort）

介绍

基数排序是一种非比较性的整数排序算法，它按照位数将整数进行排序。基数排序从最低有效位（个位）开始，依次向更高有效位进行排序。基数排序适用于整数排序，但对于整数的取值范围较大时可能不太适用。

算法步骤

按位入桶： 从最低有效位（个位）开始，将整数按照该位的值放入对应的桶中。
按顺序合并桶： 按桶的顺序，将每个桶中的元素按顺序合并。
重复上述步骤： 重复上述步骤，直到最高有效位排序完成。

Python 代码示例

def radix_sort(arr):
    # 获取最大值，以确定最高有效位数
    max_num = max(arr)
    exp = 1

    # 循环直到达到最高有效位
    while max_num // exp > 0:
        counting_sort_by_digit(arr, exp)
        exp *= 10

def counting_sort_by_digit(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10

    # 统计元素出现次数
    for i in range(n):
        index = arr[i] // exp
        count[index % 10] += 1

    # 计算累计次数
    for i in range(1, 10):
        count[i] += count[i - 1]

    # 重建有序序列
    i = n - 1
    while i >= 0:
        index = arr[i] // exp
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1

    # 将有序序列复制回原始数组
    for i in range(n):
        arr[i] = output[i]

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
radix_sort(arr)
print("基数排序结果:", arr)

特点

非比较性： 基数排序是一种非比较性的排序算法。
稳定性： 基数排序是一种稳定的排序算法，相同元素的相对位置不会改变。
时间复杂度： 基数排序的时间复杂度为O(nk)，其中n是数组长度，k是数字的最大位数。

适用场景

基数排序适用于整数排序，特别是对于位数较小的整数集。然而，对于整数的取值范围较大时，性能可能不如其他排序算法。

结语
排序算法构成了计算机科学中的基石之一，对于处理各种数据集具有重要意义。每种排序算法都有其独特的特点，适用于不同规模和类型的数据。选择合适的排序算法是优化程序性能的关键一步。希望通过本文的介绍，读者能够更好地理解和运用这些排序算法，为解决实际问题提供更有力的工具。

KH.

关注

18
点赞
踩
26

收藏

觉得还不错? 一键收藏
1
评论
探索排序算法的奇妙世界

在计算机科学的领域中，排序算法扮演着至关重要的角色。排序是一项基础而常见的任务，而不同的排序算法在处理各种情况下展现出截然不同的性能。本文将深入研究几种经典的排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序、计数排序、桶排序和基数排序。
复制链接

扫一扫