数据结构-插入类排序

1.1 直接插入排序

直接插入排序（Straight Insertion Sort）是一种简单且直观的排序算法。它的基本思想是将一个元素插入到已经排好序的序列中，从而得到一个新的有序序列。

算法步骤

1. 初始状态：将第一个元素视为有序序列，其余元素视为无序序列。
2. 遍历无序序列：从第二个元素开始，依次将每个元素插入到有序序列的适当位置。
3. 插入过程：取出当前元素，在有序序列中从后向前比较，找到合适的位置插入。

void InsertSort(int a[], int n) {
    for (int i = 1; i < n; ++i) {
        int temp = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > temp) {
            a[j + 1] = a[j];
            --j;
        }
        a[j + 1] = temp;
    }
}

时间复杂度

·最优时间复杂度：O(n); （当数组已经有序时）

·最坏时间复杂度：O(n²); （当数组逆序时）

·平均时间复杂度：O(n²); 

空间复杂度

·空间复杂度：O(1); （只需要常数级别的额外空间）;

监视哨的引入

在直接插入排序中，可以使用数组的0号元素作为监视哨以优化插入排序的实现。监视哨的作用是减少每次比较时对数组边界的检查，从而提高效率。

解释

1. 初始化监视哨：a[0] 用于存放当前待插入的元素。

2. 寻找插入位置：从后向前遍历有序序列，找到第一个小于等于 a[0] 的位置。

3. 元素后移：将大于 a[0] 的元素后移一位。

4. 插入元素：将 a[0] 插入到正确的位置。

这样，使用监视哨可以减少每次比较时对数组边界的检查，提高插入排序的效率。

#include <iostream>
using namespace std;

void InsertSort(int a[], int n) {
    for (int i = 2; i <= n; ++i) {
        a[0] = a[i]; // 将待插入元素存放到监视哨中
        int j = i - 1;
        while (a[j] > a[0]) {
            a[j + 1] = a[j];
            --j;
        }
        a[j + 1] = a[0]; // 插入待插入元素
    }
}

int main() {
    int n;
    cout << "请输入数组的大小: ";
    cin >> n;

    int a[n + 1]; // 数组大小加1，用于监视哨
    cout << "请输入数组的元素: ";
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }

    InsertSort(a, n);

    cout << "排序后的数组: ";
    for (int i = 1; i <= n; ++i) {
        cout << a[i] << " ";
    }
    cout << endl;

    return 0;
}

1.2 折半插入排序(二分插入排序)

折半插入排序（Binary Insertion Sort），又称二分插入排序，是对直接插入排序的一种改进。它通过二分查找法来确定插入位置，从而减少了比较次数，提高了排序效率。

算法步骤

1. 初始状态：将第一个元素视为有序序列，其余元素视为无序序列。

2. 遍历无序序列：从第二个元素开始，依次将每个元素插入到有序序列的适当位置。

3. 二分查找：在有序序列中使用二分查找法找到插入位置。

4. 插入过程：将元素插入到找到的位置，并将其后的元素后移。

void BinaryInsertSort(int a[], int n) { // 函数定义，接收一个整型数组和数组长度作为参数
    for (int i = 1; i < n; ++i) {      // 从数组的第二个元素开始遍历到末尾
        int temp = a[i];               // 将当前元素保存到临时变量temp中
        int low = 0, high = i - 1;     // 初始化二分查找的范围，low为数组起始位置，high为当前元素前一个位置
        while (low <= high) {          // 当low小于等于high时，表示查找范围尚未确定
            int mid = (low + high) / 2;// 计算中间位置mid
            if (a[mid] > temp) {       // 如果中间元素大于temp，则目标位置在左侧
                high = mid - 1;        // 调整high指针到mid-1
            } else {                   // 否则目标位置在右侧或等于中间元素
                low = mid + 1;         // 调整low指针到mid+1
            }
        }
        for (int j = i - 1; j >= low; --j) { // 使用low找到的位置，将大于temp的所有元素向后移动一位
            a[j + 1] = a[j];              // 移动元素
        }
        a[low] = temp;                    // 将temp放到正确的位置上
    }
}

解释

1. 二分查找：在有序序列中使用二分查找法找到插入位置，减少比较次数。

2. 元素后移：将大于待插入元素的元素后移一位。

3. 插入元素：将待插入元素放入正确的位置。

时间复杂度

·最优时间复杂度：O(nlogn)（减少了比较次数）

·最坏时间复杂度：O(n2)（移动次数不变）

·平均时间复杂度：O(n2)

空间复杂度

·空间复杂度：O(1)（只需要常数级别的额外空间）;

1.3 希尔排序(缩小增量排序)

希尔排序（Shell Sort）是插入排序的一种改进版本，也称为缩小增量排序。它通过比较相距一定间隔的元素来进行排序，各趟比较所用的间隔随着算法的进行而减小，直到最后一趟只比较相邻元素为止。

算法步骤

1. 选择增量序列：选择一个增量序列（如 n/2, n/4, ..., 1）。

2. 分组排序：根据当前增量，将数组分成若干组，对每组进行插入排序。

3. 缩小增量：减小增量，重复步骤2，直到增量为1。

void ShellSort(int a[], int n) {
    // 初始增量为数组长度的一半，然后逐步减小
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 从第 gap 个元素开始，逐个对其所在组进行插入排序
        for (int i = gap; i < n; ++i) {
            int temp = a[i]; // 保存当前元素
            int j;
            // 在当前组中进行插入排序
            for (j = i; j >= gap && a[j - gap] > temp; j -= gap) {
                a[j] = a[j - gap]; // 将大于 temp 的元素后移
            }
            a[j] = temp; // 将 temp 插入到正确的位置
        }
    }
}

解释

1. 选择增量序列：初始增量为数组长度的一半，然后逐步减小。

2. 分组排序：根据当前增量，将数组分成若干组，对每组进行插入排序。

3. 缩小增量：减小增量，重复分组排序，直到增量为1。

时间复杂度

·最优时间复杂度：O(nlog²n)

·最坏时间复杂度：O(n²)

·平均时间复杂度：O(n^{1.3})

空间复杂度

·空间复杂度：O(1)（只需要常数级别的额外空间）

稳定性

希尔排序是一种不稳定的排序算法，因为相同元素的相对顺序可能会改变。