高效排序——希尔排序

希尔排序是一种高性能的排序算法 ，其核心思想在于：

1.将数组分割为若干子数组，对每个子数组进行简单算法排序（如插入，梳排序均可）；

2.将排序后的子序列合并，继续重复步骤1；

直到所分的数组为1组。，算法结束。

       那么上述中，如何分组呢？分组方式见《C++数据结构与算法》393页最下面的划分方式，当然对于希尔排序而言，目前并没有一种理论上最优的划分方式，书上提供的是一种较为优秀的划分方式。

下面直接上代码：

# include"iostream"
# include "vector"
# include "ctime"
# include "cstdlib"  // 如果我们想通过随机数来验证我们的想法。应该预先给vecot分配内存
# include "cmath"

using namespace std;
void insert_sort(vector<int> & );
void ChooseSort(vector<int> &);
void BubbleSort(vector<int> &);
void CombSort(vector<int> & );
void ShellSort(vector<int> &);
int main()
{
    const int MAX_NUMBER = 10000;//生成的随机数的个数
    const int MIN_VALUE = 1;   //随机数值的下界
    const int MAX_VALUE = 30000;//随机数值的上界
    vector<int> a;
    a.reserve(MAX_NUMBER);//预先分配内存你，预防迭代器的失效。否则内存搬移，迭代器容易失效

    // 采用控制台输入的方式 
    //int temp;
    //while (cin >> temp)
    //{
    //    a.push_back(temp);
    //    if (cin.get() == '
') //注意这种用法，用的很多。
    //    {
    //        break;
    //    }
    //}

    //采用随机数生成法。
    srand((unsigned)time(NULL));//根据时钟生成不同的种子，保证每次运行程序产生不同的随机数
    for (int i = 1; i <= MAX_NUMBER; i++)
    {
        int temp;
        temp = (rand() % (MAX_VALUE - MIN_VALUE + 1)) + MIN_VALUE;//生成[MIN_VALUE，MAX_VALUE]之间的整数随机数
        a.push_back(temp);
    }
    //cout << "The initial order: ";    数据量太大，不适合输出
    //vector<int>::iterator ia = a.begin();
    //for (; ia != a.end(); ia++)
    //{
    //    cout << *ia << " ";
    //}
    //cout << endl;
    vector<int> b(a);
    vector<int> c(a);
    vector<int> d(a);
    vector<int> e(a);
    //show the initial order of the vector
    //cout << "The initial order before Sorting : ";
    //vector<int> ::iterator ia = a.begin();
    //for (; ia != a.end(); ia++)
    //{
    //cout << *ia << " ";
    //}
    //cout << endl;
    // 插入排序测试
    clock_t start, finish;
    double runtime;
    start = clock();
    insert_sort(a);
    finish = clock();
    runtime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "The time of Insert Sort algorithm is：" << runtime << "s" << endl;
    // 选择排序测试
    start = clock();
    ChooseSort(b);
    finish = clock();
    runtime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "The time of Choose Sort algorithm is：" << runtime << "s" << endl;
    // 冒泡排序测试
    start = clock();
    BubbleSort(c);
    finish = clock();
    runtime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "The time of Bubble Sort algorithm is：" << runtime << "s" << endl;
    // 梳排序测试
    start = clock();
    CombSort(d);
    finish = clock();
    runtime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "The time of Comb Sort algorithm is：" << runtime << "s" << endl;
    //希尔排序
    start = clock();
    ShellSort(e);
    finish = clock();
    runtime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "The time of Shell Sort algorithm is：" << runtime << "s" << endl;
    system("pause");
    return 0;
}
//插入排序
void insert_sort(vector<int> & sort_a)  ///注意，采用vector<int> 是可以作为参数进行传递的,那么是否可以作为返回类型使用呢？
{
    int a_size ,temp;
    a_size = sort_a.size();
    for (int i = 1,j; i < a_size; i++)//注意，将j放在这里声明，不要放在下一个循环中声明，否则会造成多次声明？（但是作用域没变，多次声明应该被禁止，所以没有多次声明？）
    {
        temp = sort_a[i];
        for (j = i; (j > 0) && (sort_a[j - 1] > temp); j--)//这里先后顺序的差别，导致了数组的越界，
        {   
            sort_a[j] = sort_a[j-1];
        }
        sort_a[j] = temp;
    }
    //return sort_a;//说明可以将vector<int> 本身作为函数的返回值使用,但是需要清楚的是：返回的时候，内存实际上发生了局部变量复制，所以是否考虑返回引用？？？
}
//选择排序
void ChooseSort(vector<int> & sort_a)
{
    int a_size,MinNum;
    a_size = sort_a.size();
    for (int i = 0, j; i < a_size; i++)
    {
        int Loc = i;
        MinNum = sort_a[i];//本质是随机迭代器的使用
        //temp = sort_a[i];
        for (j = i+1; j < a_size; j++)
        { 
            if (sort_a[j] < MinNum)
            {
                MinNum = sort_a[j];
                Loc = j;
            }
        }
        //sort_a[i] = MinNum;//用于交换，但是本身自带的函数可以实现
        //sort_a[Loc] = temp;
        if (i != Loc)
        {
            swap(sort_a[i], sort_a[Loc]);//vector自带的东西
        }
    }
}
//冒泡排序
void BubbleSort(vector<int> & sort_a)
{
    int a_size;
    a_size = sort_a.size();
    for (int j = 0; j < a_size-1; j++)
    {
        for (int i = 0; i < a_size - 1-j; i++)
        {
            if (sort_a[i]>sort_a[i + 1])
                 swap(sort_a[i], sort_a[i + 1]);
        }
    }
}
//梳排序
void CombSort(vector<int> & sort_a)
{
    int step,j,k;
    step = sort_a.size();
    while ((step = int(step / 1.3)) >0)
    {
        for (j = sort_a.size() - 1; j >= step; j--)
        {
            k = j - step;
            if (sort_a[j] < sort_a[k])
            {
                swap(sort_a[j], sort_a[k]);
            }
        }
    }
}

//希尔排序
void ShellSort(vector<int> & sort_a)
{
    int a_size;
    a_size = sort_a.size();//得到数组大小
    vector<int> ht;
    ht.resize(floor(log(a_size)/log(3)));//为增量数组预先分配空间
    ht[0] =1;//为何这样会出错？？？预分配空间后为何不能使用随机访问的机制？？？
    for (int i = 1; i<=ht.size()-1; i++)
    {
        ht[i] = 3 * ht[i - 1] + 1;
    }
    int ht_size = ht.size();
    vector<int> new_a;
    new_a.resize(a_size);
    for (int count = ht.size(), temp; count >= 1; count--)
    {
        temp = ht[count - 1];//temp的值决定了当前会被分成多少组
        //vector<int>a_divide;
        vector<vector<int>> aMatrix(temp, vector<int>(ceil(a_size / (1.0*temp))));//定义一个二维数组,
        for ( int i = 0; i < temp; i++)
        {
            int j;
            for (j = 0; (i + j*temp) < a_size; j++)
            {
                aMatrix[i][j] = sort_a[i + j*temp];//将应该分为同一组的数据挑选出来    
            }
            if (ceil(a_size / (1.0*temp))>j)
            {
                aMatrix[i][j] = 33333;//用于解决有0的问题
            }
           ;//问题是，本身有些空间存在0，这样写，将本身没有的0元素也进行了排序
        }
        //截止到这里，程序是没有问题的，也就是大部分是正确的，但是下面存在的问题是：数组中的0怎么办
        for(int k = 0, q = 0; k < ceil(a_size / (1.0*temp)); k++)
        {
            for (int p = 0; p < temp; p++)
            {
                sort_a[q] = aMatrix[p][k];
                q = q + 1;
                if (q >= a_size)
                    break;
            }
            if (q >= a_size)
                break;
        }
    }
        
}

实际上，上述给出很多排序算法的代码。

169-215行为希尔排序算法的实现，对算法的各个部分进行解读：

179行以前，求解每次分组的次数；

200行以前，将同一组的数据提取出来，组成一个矩阵，每行表示同一组的，不同行表示不同分组，对每行的数据采取梳排序

200行以后，将输入向量更新为矩阵列向量的拼接值

重复迭代，直到h =1；

针对希尔排序，其主要思想是一种分治的思想，给出上述排序算法效率的对比：

该次测试中，随机数的个数为10000个，从结果中可以看出，希尔排序效率最高，但其和梳排序的效率较为接近（思考原因）

在手撸希尔排序算法的过程中，遇到了很多c++中的问题，在此给出以下说明：

ht.resize(floor(log(a_size)/log(3)));这句代码的本意是给数组ht预分配空间，开始使用的是ht.reserve()，但发现这样写，在调试的时候，导致ht[0] =1;出错，这说明并没有达到我们想要的结果。百度了下，发现：

可见，使用reserve（）并不会改变vector的大小,并不会和我们想的那样在内存中开辟出一片空间给vector。因此，若我们需要开辟一块可用空间，应该用resize（）。那reserve()的作用是什么呢？（悬而未决）

vector<vector<int>> aMatrix(temp, vector<int>(ceil(a_size / (1.0*temp))));定义了一个temp×ceil(a_size / (1.0*temp))大小的二维数组aMatrix，注意这是使用vector定义的二维数组，需要注意的是vector允许这种嵌套定义。

另一个点在于CombSort(aMatrix[i])，CombSort的形参形式为数组引用，但这里传递是一个1维指针，说明某种意义上两者可以相互转换。但这个本质上说明了一个二维数组，只取一维其实就是一个指针。