当前位置：首页 > news >正文

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

news 2025/11/8 9:56:23

冒泡排序

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

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

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 次交换（比冒泡排序交换次数少）。

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 顺序改变，因此不稳定）。
适用场景：小规模数据、对交换次数敏感的场景（交换次数远少于冒泡排序）。

直接插入排序

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

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

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：此时希尔排序退化为直接插入排序，但数组已接近有序，效率大幅提升。

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)	不稳定	中等规模数据	分组优化插入排序，效率较高