希尔排序的两种思路

小费武

已于 2023-05-29 09:56:19 修改

阅读量95

点赞数 3

分类专栏：数据结构与算法文章标签：算法 c++

于 2023-05-06 17:00:03 首次发布

本文链接：https://blog.csdn.net/m0_58142184/article/details/130531162

版权

数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章提供了希尔排序的两种不同实现方式，一种基于王道课本的思路，另一种来自咸鱼学长的课堂作业。两种方法都通过调整步长进行插入排序，优化了传统插入排序的效率。在文章末尾，还展示了如何使用这两个函数对示例数组进行排序并输出结果。

摘要由CSDN通过智能技术生成

这里简单介绍希尔排序的两种思路的代码。分别是王道课本代码和咸鱼学长课堂留下的作业代码仅供参考！

课本代码

// 课本 希尔排序
void ShellSort(int A[], int n)
{
    int d, i, j;
    // A[0]只是暂存单元，不是哨兵，当J<=0时。插入位置已到
    for (d = n / 2; d >= 1; d = d / 2) // 步长变化
    {
        for (i = d + 1; i <= n; ++i)
        {
            if (A[i] < A[i - d]) // 需要将A[i]插入有序增量子列表中
            {
                A[0] = A[i]; // 暂存在A[0]
                for (j = i - d; j > 0 && A[0] < A[j]; j -= d)
                {
                    A[j + d] = A[j]; // 记录后移，查找插入位置
                }
                A[j + d] = A[0]; // 插入
            }
        }
    }
}

另一种思路代码

// 咸鱼学长 希尔排序
void Self_ShellSort(int A[], int n)
{
    // A[0]只是暂存单元，不是哨兵，当J<=0时。插入位置已到
    for (int d = n / 2; d >= 1; d = d / 2)  步长变化
    {
        // 从第一个元素开始，找到间隔d 的所有属于同一个子表的元素  ，进行插入排序
        for (int i = 1; i <= n; ++i)
        {
            for (int j = i + d; j <= n; j += d)
            {
                int k = j - d;
                if (A[j] < A[k])
                {
                    A[0] = A[j];
                    for (k; k > 0 && A[0] < A[k]; k -= d)
                    {
                        A[k + d] = A[k];
                    }
                    A[k + d] = A[0];
                }
            }
        }
    }
}

完整代码

#include <iostream>
using namespace std;
// 课本 希尔排序
void ShellSort(int A[], int n)
{
    int d, i, j;
    // A[0]只是暂存单元，不是哨兵，当J<=0时。插入位置已到
    for (d = n / 2; d >= 1; d = d / 2) // 步长变化
    {
        for (i = d + 1; i <= n; ++i)
        {
            if (A[i] < A[i - d]) // 需要将A[i]插入有序增量子列表中
            {
                A[0] = A[i]; // 暂存在A[0]
                for (j = i - d; j > 0 && A[0] < A[j]; j -= d)
                {
                    A[j + d] = A[j]; // 记录后移，查找插入位置
                }
                A[j + d] = A[0]; // 插入
            }
        }
    }
}
// 咸鱼学长 希尔排序
void Self_ShellSort(int A[], int n)
{
    // A[0]只是暂存单元，不是哨兵，当J<=0时。插入位置已到
    for (int d = n / 2; d >= 1; d = d / 2) // 步长变化
    {
        // 从第一个元素开始，找到间隔d 的所有属于同一个子表的元素  ，进行插入排序
        for (int i = 1; i <= n; ++i)
        {
            for (int j = i + d; j <= n; j += d)
            {
                int k = j - d;
                if (A[j] < A[k])
                {
                    A[0] = A[j];
                    for (k; k > 0 && A[0] < A[k]; k -= d)
                    {
                        A[k + d] = A[k];
                    }
                    A[k + d] = A[0];
                }
            }
        }
    }
}
// 输出函数
void display(int A[], int n)
{
    for (int i = 1; i <= n; ++i)
    {
        cout << A[i] << " ";
    }
    cout << endl;
}
int main()
{
    cout << "课本希尔排序:" << endl;
    int B[] = {-1, 49, 38, 65, 87, 76, 13, 27, 49};
    int N = sizeof(B) / sizeof(B[0]) - 1;
    display(B, N);
    ShellSort(B, N);
    display(B, N);
    cout << "----------------------------" << endl;

    cout << "自己修改后的希尔排序:" << endl;
    int A[] = {-1, 49, 38, 65, 87, 76, 13, 27, 49};
    int n = sizeof(A) / sizeof(A[0]) - 1;
    display(A, n);
    Self_ShellSort(A, n);
    display(A, n);

    return 0;
}