C++ 插入排序算法原理与实现

插入排序算法原理详解

算法原理

插入排序是一种基于比较的原地排序算法，它通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。类似于整理扑克牌的过程。

核心思想

1. 分界思想：将数组分为已排序部分和未排序部分
2. 逐个插入：从未排序部分取出元素，插入到已排序部分的正确位置
3. 元素后移：在插入过程中，需要将已排序部分中比当前元素大的元素向后移动

算法步骤（升序为例）

初始：[5, 3, 8, 1, 2]
第 1 轮：第一个元素 5 视为已排序
当前：[5 | 3, 8, 1, 2]
第 2 轮：取元素 3
与已排序部分比较：3 < 5
将 5 后移，3 插入到 5 的位置
结果：[3, 5 | 8, 1, 2]
第 3 轮：取元素 8
与已排序部分比较：8 > 5，位置正确
结果：[3, 5, 8 | 1, 2]
第 4 轮：取元素 1
与已排序部分从右向左比较：
1 < 8 → 8 后移
1 < 5 → 5 后移
1 < 3 → 3 后移
1 插入到最前面
结果：[1, 3, 5, 8 | 2]
第 5 轮：取元素 2
与已排序部分从右向左比较：
2 < 8 → 8 后移
2 < 5 → 5 后移
2 < 3 → 3 后移
2 > 1 → 插入到 1 后面
结果：[1, 2, 3, 5, 8]

时间复杂度分析

• 最坏情况：O(n²) - 数组完全逆序
• 最好情况：O(n) - 数组已有序
• 平均情况：O(n²)
• 空间复杂度：O(1) - 原地排序

C++ 实现代码

#include <iostream>
#include <vector>
using namespace std;

// 基础插入排序
void insertionSort(vector<int>& arr) {
    int n = arr.size();
    // 从第二个元素开始（第一个元素视为已排序）
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        // 当前要插入的元素
        int j = i - 1;
        // 将比 key 大的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + ] = arr[j];
            j--;
        }
        
        arr[j + ] = key;
    }
}


{
     n = arr.();
     ( i = ; i < n; i++) {
         key = arr[i];
         j = i - ;
        cout <<  << i <<  << i <<  << key << endl;
        cout << ;
         ( k = ; k <= i; k++) {
            cout << arr[k] << ;
        }
        cout << ;
         ( k = i + ; k < n; k++) {
            cout << arr[k] << ;
        }
        cout << endl;
         (j >=  && arr[j] > key) {
            arr[j + ] = arr[j];
            j--;
        }
        arr[j + ] = key;
        cout << ;
         ( k = ; k <= i; k++) {
            cout << arr[k] << ;
        }
         (i < n - ) {
            cout << ;
             ( k = i + ; k < n; k++) {
                cout << arr[k] << ;
            }
        }
        cout << endl << endl;
    }
}


{
     n = arr.();
     ( i = ; i < n; i++) {
         key = arr[i];
        
         left = , right = i - ;
         (left <= right) {
             mid = left + (right - left) / ;
             (arr[mid] > key) {
                right = mid - ;
            }  {
                left = mid + ;
            }
        }
        
         ( j = i - ; j >= left; j--) {
            arr[j + ] = arr[j];
        }
        
        arr[left] = key;
    }
}


{
     (n <= ) ;
    
    (arr, n - );
    
     key = arr[n - ];
     j = n - ;
     (j >=  && arr[j] > key) {
        arr[j + ] = arr[j];
        j--;
    }
    arr[j + ] = key;
}


{
     ( num : arr) {
        cout << num << ;
    }
    cout << endl;
}


{
    
    vector<> arr1 = {, , , , };
    cout <<  << endl;
    cout << ;
    (arr1);
    (arr1);
    cout << ;
    (arr1);

    
    vector<> arr2 = {, , , , };
    cout <<  << endl;
    cout << ;
    (arr2);
    cout << endl;
    (arr2);

    
    vector<> arr3 = {, , , , , };
    cout <<  << endl;
    cout << ;
    (arr3);
    (arr3);
    cout << ;
    (arr3);

    
    vector<> arr4 = {, , , , , };
    cout <<  << endl;
    cout << ;
    (arr4);
    (arr4, arr());
    cout << ;
    (arr4);

     ;
}