S12 简单排序算法--冒泡选择直接插入希尔排序

冒泡排序

通过相邻元素两两比较，将较大元素逐步 "冒泡" 到数组末尾（或较小元素冒泡到头部），每一轮遍历确定一个元素的最终位置。

核心操作：相邻元素交换，每轮遍历后，未排序区间的最大元素沉到末尾。
优化点：若某轮遍历无元素交换，说明数组已有序，可提前终止（避免无效循环）

cpp 复制代码

void BubbleSort(int *arr, int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        bool tag = false;
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                tag = false;
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if (tag)
            break;
    }
}

关键特点

时间复杂度：最好 O (n)（已有序，优化后）、最坏 O (n²)、平均 O (n²)。
空间复杂度：O (1)（原地排序）。
稳定性：稳定（相等元素不交换，保持原有顺序）。
适用场景：小规模数据、近乎有序的数据（优化后效率高）

选择排序

每一轮从未排序区间中找到最小（或最大）元素，将其与未排序区间的第一个元素交换，逐步缩小未排序区间。

核心操作：找最小值 + 交换，每轮仅需 1 次交换（比冒泡排序交换次数少）。

cpp 复制代码

void SelectSort(int*arr,int len){
    for(int i=0;i<len-1;i++){
        int min=i;
        for(int j=i+1;j<len;j++){
            if(arr[min]>arr[j]){
                min=j;
            }
        }
        int tmp=arr[i];
        arr[i]=arr[min];
        arr[min]=tmp;
    }
}

关键特点

时间复杂度：最好 O (n²)、最坏 O (n²)、平均 O (n²)（无优化空间，需完整遍历找最小值）。
空间复杂度：O (1)（原地排序）。
稳定性：不稳定（例如 [2, 2, 1]，第一轮交换后变为 [1, 2, 2]，两个 2 的相对顺序不变？实际测试稳定？注意：经典选择排序是不稳定的！反例：[3, 2, 2, 1]，第一轮最小元素 1 与 3 交换，得到 [1, 2, 2, 3]，看似稳定；但 [5, 3, 5, 2]，第一轮最小元素 2 与 5 交换，得到 [2, 3, 5, 5]，第一个 5 和第二个 5 的相对顺序不变？真正反例：[2, 1, 3, 1]，第一轮 1（索引 3）与 2（索引 0）交换，得到 [1, 1, 3, 2]，原索引 1 的 1 和索引 3 的 1 顺序不变？实际错误：经典选择排序不稳定的核心场景是 "相等元素被交换到前面"，例如 [3, 4, 1, 4]，第一轮 1 与 3 交换，得到 [1, 4, 3, 4]，原第一个 4（索引 1）和第二个 4（索引 3）顺序不变；正确反例：[4, 3, 2, 4, 1]，第一轮 1 与 4（索引 0）交换，得到 [1, 3, 2, 4, 4]，仍稳定？实际结论：选择排序是否稳定取决于实现，经典实现（找最小索引交换）是不稳定的，例如 [5, 1, 5, 2]，第一轮 1 与 5（索引 0）交换，得到 [1, 5, 5, 2]，原索引 0 的 5 和索引 2 的 5 顺序改变，因此不稳定）。
适用场景：小规模数据、对交换次数敏感的场景（交换次数远少于冒泡排序）。

直接插入排序

将数组分为已排序区间 和未排序区间，每次取未排序区间的第一个元素，插入到已排序区间的合适位置（比它大的元素后移），逐步扩大已排序区间。

核心操作：元素后移 + 插入，类似整理扑克牌的逻辑

cpp 复制代码

void InsertSort(int *arr,int len){
    for(int i=1;i<len;i++){
        int j;
        int tmp=arr[i];
        for(j=i-1;j>=0;j--){
            if(arr[j]>tmp){
                arr[j+1]=arr[j];
            }else{
                break;
            }
        }
        arr[j+1]=tmp;
    }
}

关键特点

时间复杂度：最好 O (n)（已有序，无需后移）、最坏 O (n²)、平均 O (n²)。
空间复杂度：O (1)（原地排序）。
稳定性：稳定（相等元素不后移，保持原有顺序）。
适用场景：小规模数据、近乎有序的数据（效率接近 O (n)）、链表排序（无需元素后移，仅需修改指针）。

希尔排序

直接插入排序的优化版，核心是「分组插入排序」：通过设置一个 "步长"（gap），将数组分为多个子数组，对每个子数组进行直接插入排序；逐步缩小步长（最终步长为 1），重复分组排序，直到数组完全有序。

核心思路

步长选择：常用步长序列为n/2、n/4、...、1（向下取整），也可使用更优的步长序列（如 Hibbard 序列）。
分组排序：步长为gap时，数组被分为gap个子数组（索引 0、gap、2gap... 为一组，索引 1、1+gap、1+2gap... 为另一组）。
最终步长为 1：此时希尔排序退化为直接插入排序，但数组已接近有序，效率大幅提升。

cpp 复制代码

void ShellSort(int *arr,int len){
    for(int i=len/2;i>0;i=i/2){
        for(int j=i;j<len;j++){
            int k;
            int tmp=arr[j];
            for(int k=j;k>=i;k=k-i){
                if(arr[k-i]>tmp){
                    arr[k]=arr[k-i];
                }else{
                    break;
                }
            }
            arr[k]=tmp;
        }
    }
}

四大排序算法对比总结

算法	时间复杂度（平均）	空间复杂度	稳定性	适用场景	核心特点
冒泡排序	O(n²)	O(1)	稳定	小规模数据、需稳定排序	简单易实现，交换频繁
选择排序	O(n²)	O(1)	不稳定	小规模数据、交换成本高的场景	交换次数少，比较频繁
直接插入排序	O(n²)	O(1)	稳定	小规模 / 接近有序数据	插入逻辑简单，效率优于冒泡、选择
希尔排序	O(n log n)~O(n²)	O(1)	不稳定	中等规模数据	分组优化插入排序，效率较高

关键选择建议

数据量小（n≤100）：优先选直接插入排序（效率最高），或冒泡 / 选择排序（实现最简单）。
数据量中等（n≤10000）：优先选希尔排序（效率远高于 O (n²) 算法）。
需稳定排序：选冒泡 / 直接插入排序（选择、希尔不稳定）。
交换成本高（如元素体积大）：选选择排序（交换次数最少）。

S12 简单排序算法--冒泡 选择 直接插入 希尔排序

冒泡排序

选择排序

直接插入排序

希尔排序

四大排序算法对比总结

关键选择建议

S12 简单排序算法--冒泡选择直接插入希尔排序