折半插入排序（Binary Insertion Sort）是插入排序的优化版本，其核心思路是在插入排序的"查找插入位置"环节，用折半查找（二分查找）替代传统的顺序查找，从而减少查找过程的比较次数，提升排序效率。本文将从插入排序的局限性入手，详细讲解折半插入排序的核心原理、实现步骤，提供完整的C++代码，并对算法性能进行全面分析，助力大家深入理解这一高效的插入类排序算法。
一、先回顾：传统插入排序的局限性
在讲解折半插入排序之前，我们先简要回顾传统插入排序的核心逻辑：
插入排序将数组分为"有序区"和"无序区"两部分，初始时有序区只有数组第一个元素；之后依次从无序区取出元素，在有序区中找到合适的插入位置，将其插入并调整有序区的元素位置，直到无序区为空。
传统插入排序的局限性在于：查找插入位置时采用顺序查找，从有序区的末尾开始逐一向前比较，最坏情况下需要比较 O(n) 次（如数组完全逆序时）。对于大规模数据，顺序查找的比较开销会显著降低排序效率。
而折半插入排序的优化点的正是"查找环节"------利用折半查找在有序数组中查找插入位置，将查找的时间复杂度从 O(n) 降低到 O(log n)，从而优化整体排序性能。
二、折半插入排序的核心原理
折半插入排序的核心逻辑与插入排序一致，仅在"查找插入位置"环节采用折半查找。具体步骤可分为 3 步：
1. 初始化有序区
将数组的第一个元素（索引为 0）作为初始有序区，无序区从索引 1 开始。
2. 折半查找插入位置
从无序区取出当前待插入元素（记为 temp，初始为索引 1 的元素），在有序区（范围为 [0, i-1]，i 为当前待插入元素的索引）中通过折半查找，找到 temp 的合适插入位置 pos。
折半查找的核心逻辑：
-
定义有序区的左右边界
low = 0、high = i-1； -
计算中间索引
mid = (low + high) / 2，比较temp与arr[mid]的大小：-
若
temp < arr[mid]：说明插入位置在左半区，更新high = mid - 1； -
若
temp >= arr[mid]：说明插入位置在右半区，更新low = mid + 1；
-
-
重复上述步骤，直到
low > high，此时low即为待插入元素的最终位置（因为此时 low 左侧的元素均小于 temp，右侧的元素均大于等于 temp）。
3. 插入元素并调整有序区
找到插入位置 pos 后，将有序区中从 pos 到 i-1 的所有元素依次向后移动一位（腾出插入空间），然后将 temp 插入到 pos 位置。
重复步骤 2 和 3，直到无序区的所有元素都被插入到有序区，排序完成。
三、关键细节：折半查找的插入位置判定
这里需要特别注意：折半查找的终止条件是 low > high，此时 low 就是插入位置，而非 high。我们通过一个例子说明：
假设有序区为 [2, 5, 7]（索引 0-2），当前待插入元素 temp = 4：
-
初始
low=0，high=2，mid=1，arr[mid]=5 > 4，更新high=0； -
此时
low=0，high=0，mid=0，arr[mid]=2 < 4，更新low=1； -
此时
low=1 > high=0，查找终止，插入位置为low=1； -
将有序区 [5,7] 向后移动一位，插入 4 后，有序区变为 [2,4,5,7]，符合升序要求。
若错误使用 high 作为插入位置，会导致插入位置偏左，破坏有序性。因此，折半插入排序的插入位置必然是 low，这是算法实现的关键要点。
四、完整C++代码实现
我们以升序排序为例，实现折半插入排序。代码中包含核心排序函数、辅助打印函数和测试用例，逻辑清晰，可直接复制运行。
cpp
#include <iostream>
#include <vector>
using namespace std;
// 折半插入排序（升序）
void binaryInsertionSort(vector<int>& arr) {
int n = arr.size();
if (n <= 1) {
return; // 数组长度为0或1时，无需排序
}
// 从索引1开始遍历无序区（索引0为初始有序区）
for (int i = 1; i < n; ++i) {
int temp = arr[i]; // 保存当前待插入的元素
int low = 0; // 有序区左边界
int high = i - 1; // 有序区右边界
// 步骤1：折半查找插入位置
while (low <= high) {
int mid = (low + high) / 2; // 中间索引（避免溢出可优化为 low + (high - low)/2）
if (temp < arr[mid]) {
high = mid - 1; // 插入位置在左半区
} else {
low = mid + 1; // 插入位置在右半区
}
}
// 步骤2：将有序区中[low, i-1]的元素向后移动一位，腾出插入空间
for (int j = i - 1; j >= low; --j) {
arr[j + 1] = arr[j];
}
// 步骤3：将待插入元素插入到low位置
arr[low] = temp;
}
}
// 辅助函数：打印数组
void printArray(const vector<int>& arr) {
for (int num : arr) {
cout << num << " ";
}
cout << endl;
}
// 测试代码
int main() {
// 测试用例1：普通无序数组
vector<int> arr1 = {12, 11, 13, 5, 6, 7};
cout << "测试用例1 - 排序前：";
printArray(arr1);
binaryInsertionSort(arr1);
cout << "测试用例1 - 排序后：";
printArray(arr1);
// 测试用例2：完全逆序数组（最坏情况）
vector<int> arr2 = {6, 5, 4, 3, 2, 1};
cout << "\n测试用例2 - 排序前：";
printArray(arr2);
binaryInsertionSort(arr2);
cout << "测试用例2 - 排序后：";
printArray(arr2);
// 测试用例3：已有序数组（最好情况）
vector<int> arr3 = {1, 2, 3, 4, 5, 6};
cout << "\n测试用例3 - 排序前：";
printArray(arr3);
binaryInsertionSort(arr3);
cout << "测试用例3 - 排序后：";
printArray(arr3);
return 0;
}代码优化与说明
-
溢出优化 ：折半查找中计算 mid 时，
(low + high) / 2可能因 low 和 high 过大导致整数溢出，可优化为low + (high - low) / 2，两者结果一致，但能避免溢出问题； -
边界处理：代码开头判断数组长度 ≤ 1 时直接返回，避免无效排序；
-
通用性：使用 vector 存储数组，支持动态长度，适配不同规模的排序需求；
-
测试用例覆盖：包含普通无序、完全逆序、已有序三种典型情况，可验证算法在不同场景下的正确性。
五、算法性能分析
1. 时间复杂度
折半插入排序的时间复杂度由"折半查找时间"和"元素移动时间"两部分组成：
-
折半查找时间：对于每个待插入元素，查找过程的时间复杂度为 O(log n)，共需要插入 n-1 个元素，因此查找总时间为 O(n log n)；
-
元素移动时间：与传统插入排序一致，最坏情况下（数组完全逆序），每个元素需要移动 O(n) 次，总移动时间为 O(n²)；最好情况下（数组已有序），无需移动元素，移动时间为 O(n)；
-
整体时间复杂度：最坏和平均时间复杂度为 O(n²)，最好时间复杂度为 O(n log n)。
注意：虽然折半查找优化了查找环节，但元素移动环节的时间复杂度仍为 O(n²)，因此折半插入排序的整体时间复杂度与传统插入排序相同。但在实际应用中，折半查找减少了比较次数，对于大规模数据，其效率仍优于传统插入排序。
2. 空间复杂度
折半插入排序是原地排序算法，仅使用了常数级的额外空间（如 temp、low、high、mid 等变量），因此空间复杂度为 O(1)。
3. 稳定性
折半插入排序是稳定排序算法 。因为在查找插入位置时，对于相等的元素，折半查找会将插入位置确定在相等元素的右侧（通过 temp >= arr[mid] 时更新 low = mid + 1 实现），不会改变相等元素的相对位置。例如，数组 [2, 2, 1]，排序后仍为 [1, 2, 2]，两个 2 的相对位置未变。
六、折半插入排序的应用场景
折半插入排序适合以下场景：
-
数据量较小的场景：当 n ≤ 1000 时，O(n²) 的时间复杂度不会带来明显的性能问题，且算法实现简单、空间开销小；
-
数据基本有序的场景：此时元素移动次数少，折半查找的优势能进一步凸显，排序效率接近 O(n log n)；
-
对空间开销敏感的场景：原地排序特性使其在内存有限的环境（如嵌入式系统）中具有优势；
-
需要稳定排序的场景：相较于不稳定的排序算法（如快速排序、堆排序），折半插入排序能保证相等元素的相对位置不变。
七、与传统插入排序的对比
| 对比维度 | 传统插入排序 | 折半插入排序 |
|---|---|---|
| 查找方式 | 顺序查找 | 折半查找 |
| 查找时间复杂度 | O(n) | O(log n) |
| 整体时间复杂度 | O(n²)（最坏、平均），O(n)（最好） | O(n²)（最坏、平均），O(n log n)（最好） |
| 比较次数 | 较多（顺序比较） | 较少（折半比较） |
| 稳定性 | 稳定 | 稳定 |
| 空间复杂度 | O(1) | O(1) |
八、总结
折半插入排序是对传统插入排序的针对性优化，通过折半查找将查找环节的时间复杂度从 O(n) 降低到 O(log n)，减少了比较次数，提升了实际排序效率。其核心优势在于"原地排序""稳定排序"和"实现简单"，适合数据量较小、基本有序或对空间敏感的场景。