插入排序的三种C++实现方法详解

原创于 2025-04-11 21:25:29 发布 · 872 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法 #数据结构 #c++

插入排序是一种简单直观的排序算法，特别适合小规模数据或基本有序的数据集。本文将介绍插入排序的三种C++实现：直接插入排序、二分插入排序和希尔排序。

1. 直接插入排序 (Straight Insertion Sort)

算法原理

直接插入排序是最基础的插入排序实现，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

C++实现

#include <iostream>
#include <vector>

void straightInsertionSort(std::vector<int>& arr) {
    for (size_t i = 1; i < arr.size(); ++i) {
        int key = arr[i];
        int j = static_cast<int>(i) - 1;
        
        // 将大于key的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j + 1] = key;
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6};
    
    std::cout << "原始数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    straightInsertionSort(arr);
    
    std::cout << "排序后数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    return 0;
}

复杂度分析

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定

2. 二分插入排序 (Binary Insertion Sort)

算法原理

二分插入排序是对直接插入排序的改进，通过使用二分查找来减少比较次数，但移动元素的次数不变。

C++实现

#include <iostream>
#include <vector>

void binaryInsertionSort(std::vector<int>& arr) {
    for (size_t i = 1; i < arr.size(); ++i) {
        int key = arr[i];
        int left = 0;
        int right = static_cast<int>(i) - 1;
        
        // 二分查找插入位置
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] > key) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        
        // 移动元素
        for (int j = static_cast<int>(i); j > left; --j) {
            arr[j] = arr[j - 1];
        }
        
        arr[left] = key;
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6};
    
    std::cout << "原始数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    binaryInsertionSort(arr);
    
    std::cout << "排序后数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    return 0;
}

复杂度分析

时间复杂度：比较次数O(nlogn)，移动次数O(n²)
空间复杂度：O(1)
稳定性：稳定

3. 希尔排序 (Shell Sort)

算法原理

希尔排序是插入排序的高效改进版本，通过将整个待排序的记录序列分割成若干子序列分别进行直接插入排序，随着增量逐渐减小，整个序列趋于有序。

C++实现

#include <iostream>
#include <vector>

void shellSort(std::vector<int>& arr) {
    int n = static_cast<int>(arr.size());
    
    // 初始间隔设为数组长度的一半，逐步缩小
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 对每个子数组进行插入排序
        for (int i = gap; i < n; ++i) {
            int temp = arr[i];
            int j;
            
            // 对子数组进行插入排序
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            
            arr[j] = temp;
        }
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6, 7, 8, 1, 2, 3};
    
    std::cout << "原始数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    shellSort(arr);
    
    std::cout << "排序后数组: ";
    for (int num : arr) std::cout << num << " ";
    std::cout << "\n";
    
    return 0;
}

复杂度分析

时间复杂度：取决于间隔序列，最好O(nlog²n)
空间复杂度：O(1)
稳定性：不稳定

三种方法比较

排序方法	时间复杂度(平均)	时间复杂度(最坏)	空间复杂度	稳定性
直接插入排序	O(n²)	O(n²)	O(1)	稳定
二分插入排序	O(n²)	O(n²)	O(1)	稳定
希尔排序	O(nlog²n)	O(n²)	O(1)	不稳定

实际应用建议

小规模数据（<1000元素）：直接插入排序或二分插入排序
- 实现简单
- 对小数据集效率高
- 适合链表结构
中等规模数据：希尔排序
- 插入排序家族中性能最好
- 适合数组结构
大规模数据：考虑更高效的算法（如快速排序、归并排序等）

总结

插入排序虽然在大规模数据排序中效率不高，但其简单直观、空间效率高的特点使其在特定场景下仍有应用价值。三种插入排序方法各有优缺点：

直接插入排序：实现最简单，适合教学和小数据集
二分插入排序：减少了比较次数，适合比较操作代价高的场景
希尔排序：性能最好，是插入排序家族中最实用的变种

希望这篇博客能帮助你更好地理解插入排序的三种实现方法！