希尔排序

前面几篇文章，如冒泡排序、简单选择排序和直接插入排序，它们的算法复杂度皆为 o(n^2)，然而是否所有的排序算法，都无法突破这个数字，显然不是。希尔排序（Shell sort）是D.L.Shell于1959年提出的一种排序算法，它是最早突破 o(n^2)这个复杂度的算法之一。

希尔排序与直接插入排序的异同点：
1、希尔排序时插入排序方法的一种，其原理为分组插入排序。它将无序数组分割为若干个子序列，子序列不是逐段分割的，而是相隔特定的增量的子序列，对各个子序列进行插入排序；然后再选择一个更小的增量，再将数组分割为多个子序列进行排序……最后选择增量为1，即使用直接插入排序，使最终数组成为有序。
2、由上面的定义也可以看出，直接插入排序是希尔排序的最后一环，或者说是分组增量恒定为1的希尔排序.
3、我们知道直接插入排序，是可以直接让数列变得有序的，那为什么希尔排序还要在最后一环之前，做那么多分组增量大于1的排序呢？这是因为直接插入排序在数列基本有序的情况下，效率非常高，因此其前面的分组插入是为了使数列基本有序，从而使整个插入算法的效率提高。
（基本有序，就是小的关键字基本在前面，大的基本在后面，不大不小的基本在中间）

增量选择：
在每趟的排序过程都有一个增量，至少满足一个规则 增量关系 d[1] > d[2] > d[3] >..> d[t] = 1 (t趟排序)；根据增量序列的选取其时间复杂度也会有变化，这个不少论文进行了研究，在此处就不再深究；
本文采用首选增量为n/2,以此递推，每次增量为原先的1/2，直到增量为1；

希尔排序时间复杂度：
其时间复杂度涉及到增量的选择，在某些序列中可以达到 O(n^1.5)
它是一种不稳定的算法。
（排序算法稳定性：假设Ki = Kj（1<=i<=n，1<=j<=n ,i != j），且在排序前的序列中 ri 领先于 rj（即 i < j）。如果排序后 ri 仍领先于 rj，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列中 rj 领先于 ri，则称所用的排序方法是不稳定的。）

希尔排序过程如下：

代码及结果如下：

#include <iostream>

using namespace std;

const int MAX_SIZE = 10;

class Base{
private:
    int r[MAX_SIZE];     /**待排序数列存放处**/
    int length;          /**顺序表长度，即数据元素个数**/
public:
    Base()
    {
        r[0] = 1;
        r[1] = 2;
        r[2] = 0;
        r[3] = 5;
        r[4] = 8;
        r[5] = 9;
        r[6] = 7;
        r[7] = 3;
        r[8] = 6;
        r[9] = 4;
        length = 10;
    }
    void Show(const Base &ob);
    friend int Shell_sort(Base &ob);    /**希尔排序函数，设为该类的友元函数，以便操作类的私有数据成员**/
};

void Base::Show(const Base &ob)         /**用于输出数据**/
{
    int i;
    for(i = 0;i < ob.length;i++)
        cout << ob.r[i] << ' ';
    cout << endl;
}

/**希尔排序函数，参考希尔排序原理，针对直接插入排序算法写的**/
int Shell_sort(Base &ob)
{
    int i,j;
    int temp;
    int d_inc;               /**表示增量**/
    d_inc = ob.length / 2;
    while (d_inc >= 1)       /**这里一定是<=,当d_inc=1时,即为直接插入排序**/
    {                        /**不要少了“=”，不然没有最后一次直接插入排序，排出来的数列，仅为基本有序数列**/
        for(i = d_inc; i < ob.length; i++)   /**针对增量参数，修改后的直接插入排序算法**/
        {                                    /**注意这里 i 是每次加1，而不是加 d_inc**/
            temp = ob.r[i];
            for(j = i - d_inc; j >= 0 && ob.r[j] > temp; j = j - d_inc)  /**这里 j 需要减d_inc，和上面的 i 搭配**/
            {
                ob.r[j + d_inc] = ob.r[j];       /**移位，为即将插入的temp空出位置**/
            }
            ob.r[j + d_inc] = temp;              /**找到位置后插入temp**/
        }
        d_inc = d_inc / 2;                       /**增量减小**/
    }
    return 0;
}

int main()
{
    Base ob1;
    cout << "排序前的数列: " << endl;
    ob1.Show(ob1);

    Shell_sort(ob1);
    cout << "希尔排序后的数列（小的放前面）: " << endl;
    ob1.Show(ob1);

    return 0;
}

/点滴积累，我的一小步O(∩_∩)O~/

/本文有借鉴参考这一篇博客：http://blog.csdn.net/cjf_iceking/article/details/7951481/