[数据结构]希尔排序

一、问题描述

内部排序是一件具有重大意义的问题，许多项目的实现中都需要用到排序。

我们知道，排序的算法有许多种，每种排序算法的时间复杂度和空间复杂度不尽相同。在解决实际问题时，往往需要根据实际需要选择排序算法。

本实验重点介绍希尔排序的算法实现及其原理，简要说明与其相关的直接排序算法，并讨论希尔排序中步长的选择对排序速度的影响。

二、数据结构——顺序结构

本实验重点在算法实现上，数据结构的思想被弱化了。在排序过程中，由于维护序关系的需要，要有交换的操作，这就破坏了ADT的物理位置的相邻反映逻辑的依次的性质，可以说这里的顺序结构只是一个二次结构。因此，本实验不对此作过多说明。

三、算法的设计和实现

（1）直接排序（直接插入排序）

a)简述

以不降序排序为例，直接排序在每一轮排序中，找到出现的第一个破坏不降序性质的元素，将其值保存至a[0]处，然后向前扫，直到找到小于或等于a[0]的元素a[i]，然后将a[0]插入到a[i]之后，后面的元素依次后移一位。重复上述过程，由循环不变式可知，最后得到的序列是保持不降序性质的。

可以看出，直接排序是一种基于插入的排序算法。算法的时间复杂度为O(n^2)。值得注意的是，直接排序只涉及到两个相邻数的交换，所以是稳定的。

b)例子：空白处的表示不改变，当前循环将不会访问到。

a[0]	49	38	65	97	76	13	27
38	38	49
76	38	49	65	76	97
13	13	38	49	65	76	97
27	13	27	38	49	65	76	97

（1）希尔排序

a)简述

希尔排序是直接排序的一个升级版。以步长将待排序的序列划分成几个部分，将每个部分进行排序，使得整个序列粗有序，从而减少序列的移动次数，减小时间复杂度。

b)算法描述

首先枚举步长gap，以步长将待排序的序列分为gap个子序列，对每个子序列进行直接排序。步长从粗到细，最后一次步长为1。步长的选取直接关系到希尔排序的时间效率，一般来说，为了尽量避免重复计算，选取的步长要互质；至于更系统的讨论将在下面给出。

c)例子

步长	49	38	65	97	76	13	27	49	55	4
5	13	27	49	55	4	49	38	65	97	76
3	13	4	49	38	27	49	55	65	97	76
1	4	13	27	38	49	49	55	65	76	97

d)可以看出，希尔排序不仅基于插入，还有大跨度交换的操作，所以希尔排序是不稳定的。

四、预期结果和实验中的问题

1、预期结果

程序能够正确地将一个序列按照不递减的顺序排序。下图为一个例子。

2、实验中的问题及思考

（1）问题：希尔排序的步长选择对算法效率的影响。

（2）解答：这是一个公开问题，似乎还没有一个特别完美的解释。维基百科上有相关的说明。https://en.wikipedia.org/wiki/Shellsort

附：c++源代码：

/*
项目：shell sort
作者：张译尹
*/
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
#define MaxN 120

int gap[200]; //步长 2^k+1 第一项改为1 
int n;

template <class T> class My_list
{
private:
    T Elem[MaxN]; //待排序的元素 
    int Len; //元素个数 
public:
    void Init()
    {
        memset(Elem, 0, sizeof(Elem));
        Len = 0;
    }
    void Insert_back(T x)
    {
        Elem[++Len] = x;
    }
    void Print()
    {
        int i;
        for(i = 1; i < Len; i++)
            printf("%d ", Elem[i]);
        printf("%d
", Elem[i]);
    }
    int GetLen()
    {
        return Len;
    }
    void ShellSort()
    {
        int i, j, k;
        for(k = gap[0]; k >= 1; k--)
        {
            for(i = gap[k]; i <= Len; i++)
            {
                Elem[0] = Elem[i];
                
                //把比当前元素大的都往后移动 
                for(j = i - gap[k]; j >= 0 && Elem[0] < Elem[j]; j -= gap[k])
                    Elem[j + gap[k]] = Elem[j];
                Elem[j + gap[k]] = Elem[0];
            }
        }
    }
};

void Read(My_list <int> &L)
{
    int i, x;
    L.Init();
    printf("请输入需要排序的数的个数。
");
    scanf("%d", &n);
    printf("请输入需要排序的数列。
"); 
    for(i = 1; i <= n; i++)
    {
        scanf("%d", &x);
        L.Insert_back(x); //把x插入到最后 
    }
}

void Pre_gap(My_list <int> &L)
{
    int i, tmp = 2, n = L.GetLen();
    for(i = 2; ; i++)
    {
        tmp = ((tmp - 1) << 1) + 1;
        gap[i] = tmp;
        if(tmp >= n / 2)
            break;
    }
    gap[1] = 1;
    gap[0] = i;
}

int main()
{
    int GapNum;
    My_list <int> L;
    Read(L);
    Pre_gap(L);
    L.ShellSort();
    printf("升序排序后的数列：
");
    L.Print();
    return 0;
}