希尔排序算法——C/C++

希尔排序

1. 算法思想

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dn=1(<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

2. 排序步骤

2.1、第一次，取一个增量increment，一般是increment=n/3（最开始是n/2，可以根据自己想法修改，只是影响计算时间）。
2.2、把相差为增量倍数的分为一组。
2.3、分组后，在组内进行直接插入排序。
2.4、重复上述三步，直到increment=1结束。

3. 动态演示

4. 完整代码

值得说一下，插入排序的间隔是增量大小
我写的有点复杂，套了四个加一个判断，不过应该条理清晰，理解容易。

4.1 核心函数

排序函数：void shell_sort(int* array, int size)

4.2 代码

#include <stdio.h>
#include <stdlib.h> // rand() srand()
#include <time.h>   // time()

void display(int* array, int size); // 打印函数
int  check(int* array, int size);   // 检查函数

/**
 * @brief 希尔排序
 * 
 * @param array        数组首地址
 * @param size         数组大小
 */
void shell_sort(int* array, int size)
{
    // 初始化临时值，增量
    int key       = 0;
    int increment = size;
    do {
        // 每次减小增量，直到increment = 1
        increment = increment / 2;
        for (int i = 0; i < increment; i++) {
            // 对每个划分进行直接插入排序
            for (int j = i + increment; j < size; j = j + increment) {
                if (array[j] < array[j - increment]) {
                    key   = array[j];
                    int k = j - increment;
                    do {
                        // 移动元素并寻找位置
                        array[k + increment] = array[k];
                        k                    = k - increment;
                    } while (key < array[k] && k >= 0);
                    // 插入元素
                    array[k + increment] = key;
                }
            }
        }
    } while (increment != 1);
}

int main()
{
    // 测试用例
    // int array[]    = {49, 38, 65, 97, 76, 13, 27, 49, 10};
    // int array_size = sizeof(array) / sizeof(array[0]);
    // printf("%d \n", array_size);
    // printf("排序前数组：");
    // display(array, array_size);
    // shell_sort(array, array_size);
    // printf("排序后数组：");
    // display(array, array_size);

    // 随机测试
    int array_num  = 20;             // 数组数量
    int array_size = 20;             // 数组大小
    int array[array_size];           // 数组初始化
    srand((unsigned int)time(NULL)); // 随机数种子，保证每次不一样
    for (int i = 0; i < array_num; i++) {
        for (int j = 0; j < array_size; j++) {
            array[j] = rand() % 1000; // 随机生成数大小 0~999
        }
        printf("原来的数组：");
        display(array, array_size);
        shell_sort(array, array_size);
        printf("排序后数组：");
        display(array, array_size);
        // 检测排序结果
        if (check(array, array_size) != 0) {
            exit(-1);
        }
        printf("\n");
    }

    return 0;
}

/**
 * @brief 打印函数
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
void display(int* array, int size)
{
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

/**
 * @brief 检查函数，从小到大
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
int check(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        if (array[i] > array[i + 1]) {
            printf("sort array fail...\n");
            return -1;
        }
    }
    printf("sort array success...\n");
    return 0;
}

5. 结果展示

（显示每次排序结果）

6. 算法分析

时间复杂度：

1. 最好O(n log^1.3 n)
2. 最坏O(n log^2 n)

空间复杂度：O(1)

稳定性：不稳定