希尔排序算法实现

希尔算法的核心思想是：
将一组数据划分为多个组分别进行插入排序。
希尔排序提出了一个增量的概念，以间隔一定值进行分组,这个一定值就是 增量
通常增量的值采用上一次的增量值除以2，第一次为n/2(n为数组个数)
譬如：
{12，54，22，11，8，10，7，8，58，3}
第一次增量为n/2，这里n 为10 所以增量为10/2=5
所以第一次分组后：
下标关系为：
{0，5}
{1，6}
{2，7}
{3，8}
{4，9}
即：
{12，10}
{54，7}
{22，8}
{11，58}
{8，3}
第二次为：n/2/2,第三次为n/2/2/2 … 最后一次是1

希尔排序每次增量的值，就是每次分完组后的组数。
第一次增量是n/2，那么组数也是n/2，每组 2 个数。
第二次增量是n/2/2,那么组数是n/4，每组4个数。
…
直到组数为1 ,每组个数为n
那么每次分组每组比较次数为 1 3 7 … 2n - 1
那么每次分组的比较次数为 组数 * 每组 的次数

组数为n/2,n/4,n/8 … 1，即 n/2¹,n/2²… n/n
所以总共的次数为 n/2 * (2¹ -1) + n/4 * (2² -1) …n-1
=>
理论上是 log2n次，理论上就是 log2n * n - (n/2 + n/4 + …) + n - 1
等比数列前log2n 次和 (n/2 + n/4 + …),带入等比数列前n项和
n(1- 1/2(log₂n)) + n-1
=>
nlog₂n + 2n + xxxxxx
所以希尔排序的复杂度是 O(nlog₂n)
具体实现如下：

#include <iostream>
#include <algorithm>
using namespace std;
//直接插入排序
void InsertSoft(int* array,int length,int span)
{
 if(array != NULL && length > 0 && span >= 1)
 {
     for(int i = span;i < length; i = i+ span)
     {
         int curValue = array[i];
         int prvIndex = i - span;
         while(prvIndex >= 0 && array[prvIndex] > curValue)
         {
             array[prvIndex + span] = array[prvIndex];
             prvIndex -= span;
         }
         
         array[prvIndex + span] = curValue;
     }
 }
}

//希尔排序
void ShellSort(int* array,int length)
{
    if(array != NULL && length>0)
    {
        for(int span = length / 2;span >=1;span = span / 2)
        {
            for(int i = span; i < length;i++)
            {
                InsertSoft(array,length,span);
            }
        }
    }
}

int main() {
    int array[] = {12,31,1,21,11,3,56,14,89,10};
    int length = sizeof(array) / sizeof(array[0]);
    
    //InsertSoft(array,length,1);
    
    ShellSort(array,length);
    
    std::for_each(array,array+length,[](int i){
        
        std:: cout << i << " ";
    });
    
    std::cout << std::endl;
    
	cout  << "test\n";
	return 0;
}

注：希尔排序不是稳定的排序，因为在分组排序中 相同的值的相对大小位置是发生了变化的。

希尔排序的关键在于分组和分组比较。