数据结构八大排序：希尔排序-原理解析+C语言实现+优化+面试题

violet-lz2025-10-22 18:35

一、希尔排序算法概述

希尔排序是Donald Shell在1959年提出的一种改进的插入排序算法，也称为缩小增量排序。它是第一批突破O(n²)时间复杂度的算法之一，通过将原始列表分割成多个子序列分别进行插入排序，从而大幅提高排序效率。

希尔排序特点1：数据量小的时候，效率更高

希尔排序特点2：数据越有序，效率越高

基本特性：

平均时间复杂度：O(n^1.3) 到 O(n²)

最好时间复杂度：O(nlogn)

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

空间复杂度：O(1)

稳定性：不稳定排序

二、希尔排序核心思想

2.1 算法基本思路

希尔排序的核心思想是：先将整个待排序记录序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行一次直接插入排序。

2.2 增量序列选择

增量序列的选择对希尔排序的性能至关重要，常见的增量序列有：

Shell原始序列：gap = n/2, n/4, ..., 1（本文以Shell增量序列为例）

Hibbard序列：1, 3, 7, ..., 2^k-1

Sedgewick序列：1, 5, 19, 41, ...

三、希尔排序过程详解

3.1 排序过程图解

以数组 [8, 9, 1, 7, 2, 3, 5, 4, 6, 0] 为例：

初始状态： [8, 9, 1, 7, 2, 3, 5, 4, 6, 0]

第一次分组（gap=5）：

分组：[8,3], [9,5], [1,4], [7,6], [2,0]

组内排序：[3,8], [5,9], [1,4], [6,7], [0,2]

结果：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]

第二次分组（gap=2）：

分组：[3,1,0,9,7], [5,6,8,4,2]

组内排序：[0,1,3,7,9], [2,4,5,6,8]

结果：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]

第三次分组（gap=1）：

直接插入排序得到最终结果

四、希尔排序C语言实现

4.1 基础版本实现

复制代码 
#include <stdio.h>
void shellSort(int arr[], int n) {
    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;
        }
    }
}
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
}
int main() {
    int arr[] = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("原数组: ");
    printArray(arr, n);
    shellSort(arr, n);
    printf("排序后: ");
    printArray(arr, n);
    return 0;
}

4.2 优化版本实现

复制代码 
#include <stdio.h>
void optimizedShellSort(int arr[], int n) {
    int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
    int gapsCount = 8;
    for (int k = 0; k < gapsCount; k++) {
        int gap = gaps[k];
        if (gap > n) continue;
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
    }
}
int main() {
    int arr[] = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("原数组: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    optimizedShellSort(arr, n);
    printf("优化排序后: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

五、复杂度分析与性能比较

5.1 时间复杂度分析

最好情况：O(nlogn) - 使用优化的增量序列

平均情况：O(n^1.3) 到 O(n^1.5)

最坏情况：O(n²) - 使用Shell原始序列

5.2 空间复杂度分析

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

5.3 稳定性分析

希尔排序是不稳定的排序算法，因为相同的元素可能会被分到不同的组中，从而改变它们的相对顺序。

六、希尔排序与其他排序算法比较

特性 希尔排序 插入排序 快速排序
平均时间复杂度 O(n^1.3) O(n²) O(nlogn)
空间复杂度 O(1) O(1) O(logn)
稳定性 不稳定 稳定 不稳定
适用场景 中等规模数据 小规模或基本有序 大规模随机数据

七、希尔排序的优化策略

7.1 增量序列优化

复制代码 
// Hibbard增量序列
void hibbardShellSort(int arr[], int n) {
    int k = 1;
    while ((1 << k) - 1 < n) k++;
    for (; k > 0; k--) {
        int gap = (1 << k) - 1;
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
    }
}

7.2 Sedgewick增量序列

复制代码 
void sedgewickShellSort(int arr[], int n) {
    int sedgewick[] = {1, 5, 19, 41, 109, 209, 505, 929, 2161, 3905, 8929, 16001};
    int s = 0;
    while (sedgewick[s] < n) s++;
    for (s--; s >= 0; s--) {
        int gap = sedgewick[s];
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
    }
}

八、使用注意事项与最佳实践

8.1 适用场景

  1. 中等规模数据：希尔排序在数据量不是特别大时表现良好

  2. 内存受限环境：空间复杂度为O(1)，适合嵌入式系统

  3. 需要不稳定排序：当稳定性不是关键要求时

8.2 注意事项

  1. 增量序列选择：选择合适的增量序列对性能影响很大

  2. 边界条件处理：注意数组越界问题

  3. 数据特性：对于部分有序数据效果更好

  4. 实现复杂度：相比简单插入排序实现稍复杂

8.3 最佳实践建议

复制代码 
// 推荐的希尔排序实现模板
void recommendedShellSort(int arr[], int n) {
    if (n <= 1) return;
    if (n <= 10) {
        // 小数组使用直接插入排序
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
        return;
    }
    // 中等规模使用优化增量序列
    int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
    for (int k = 0; k < 8; k++) {
        int gap = gaps[k];
        if (gap > n) continue;
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
    }
}

九、希尔排序实际应用

9.1 文件排序应用

复制代码 
#include <stdio.h>
#include <string.h>
void sortStrings(char *arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            char *temp = arr[i];
            int j;
            for (j = i; j >= gap && strcmp(arr[j - gap], temp) > 0; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}
int main() {
    char *names[] = {"张三", "李四", "王五", "赵六", "钱七"};
    int n = 5;
    printf("排序前: ");
    for (int i = 0; i < n; i++) printf("%s ", names[i]);
    printf("\n");
    sortStrings(names, n);
    printf("排序后: ");
    for (int i = 0; i < n; i++) printf("%s ", names[i]);
    printf("\n");
    return 0;
}

9.2 结构体排序

复制代码 
#include <stdio.h>
typedef struct {
    int id;
    char name[20];
    int score;
} Student;
void sortStudents(Student arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            Student temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap].score > temp.score; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

十、常见面试题精讲

10.1 基础概念题

  1. 希尔排序为什么比直接插入排序效率高？

    答：希尔排序通过分组减少了数据移动的次数，先进行宏观调整再进行微观调整

  2. 希尔排序的时间复杂度是多少？为什么不稳定？

    答：平均O(n^1.3)，不稳定是因为相同元素可能被分到不同组

  3. 希尔排序和插入排序的主要区别是什么？

    答：希尔排序是插入排序的改进，通过分组排序减少数据移动距离

10.2 编码实现题

复制代码 
// 题目1：使用希尔排序找出数组前k小的元素
void findKSmallest(int arr[], int n, int k) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
        }
    }
    printf("前%d小的元素: ", k);
    for (int i = 0; i < k; i++) printf("%d ", arr[i]);
    printf("\n");
}

10.3 算法分析题

  1. 给定10^5个整数，希尔排序和快速排序哪个更合适？为什么？

    答：快速排序更合适，因为希尔排序在最坏情况下可能达到O(n²)

  2. 如何证明希尔排序是不稳定的？

    答：构造包含相同元素的序列，观察排序后相对位置变化

  3. 希尔排序在实际工程中的应用场景有哪些？

    答：嵌入式系统排序、中等规模数据排序、内存受限环境

10.4 进阶思考题

复制代码 
// 题目：实现双向希尔排序（同时向前向后比较）
void bidirectionalShellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n - gap; i++) {
            int temp = arr[i];
            int j = i;
            // 向前比较
            while (j >= gap && arr[j - gap] > temp) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = temp;
            // 向后比较
            if (i + gap < n && arr[i] > arr[i + gap]) {
                int temp2 = arr[i];
                arr[i] = arr[i + gap];
                arr[i + gap] = temp2;
            }
        }
    }
}

总结

希尔排序作为插入排序的重要改进，通过分组策略有效减少了数据移动次数，在中等规模数据排序中表现出色。掌握希尔排序的核心思想、不同增量序列的选择以及优化技巧，对于理解排序算法的发展和实际应用具有重要意义。在实际编程中，应根据具体场景选择合适的增量序列，并注意算法的稳定性和边界条件处理。

相关推荐
ezl1fe4 小时前
第一篇：把任意 HTTP API 一键变成 Agent 工具
人工智能·后端·算法
冯诺依曼的锦鲤4 小时前
算法练习：双指针专题
c++·算法
吃着火锅x唱着歌4 小时前
LeetCode 668.乘法表中第k小的数
算法·leetcode·职场和发展
前端小刘哥4 小时前
互联网直播点播平台EasyDSS流媒体技术如何赋能多媒体展厅智能化升级？
算法
Python算法实战5 小时前
平安大模型面试题：Self-Attention 原理与多头注意力设计
人工智能·算法·自然语言处理·大模型·面试题
Python算法实战5 小时前
腾讯送命题：手写多头注意力机制。。。
人工智能·算法·面试·大模型·强化学习
前端小刘哥5 小时前
现场直播的技术革新者：视频直播点播平台EasyDSS在现场直播场景中的技术应用
算法
草莓工作室5 小时前
数据结构9:队列
c语言·数据结构·队列
violet-lz5 小时前
数据结构八大排序：堆排序-从二叉树到堆排序实现
数据结构·算法
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南082025软件测试面试八股文（含答案+文档）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10Labelme从安装到标注：零基础完整指南