插入排序——希尔排序

希尔排序其实就是一种插入排序，实际上就是通过直接插入排序一步步改进优化而实现的。所以在了解希尔排序之前要明白插入排序的实现原理。

插入排序

 其实我觉得插入排序也可以叫做摸牌排序，就是从第二张牌开始处理，将摸到的牌按照合适的顺序插入到对应的牌堆里。

代码展示

void InsertSort(int* arr, int n)//n是元素个数
{
    //实现升序
	int i, j;
	for (i = 1; i < n; i++)//插入的每一个数，从第二个数开始
	{
		int tmp = arr[i];//临时存放
		for (j = i - 1; j >= 0; j--)//往已经排序好的数据中比较插入
		{
			if (tmp < arr[j])
				arr[j + 1] = arr[j];
			else//大于前面的值
				break;
		}
		//最小值或者是break了
		arr[j + 1] = tmp;
	}
}

 其实插入排序从第二个数开始的原因就是为了保证前面的牌都是有序的，并且将需要插入的牌临时存放起来，并依次与前面的有序牌一一比较，将前面较大值的牌向后移动一位，直到循环停止或者是前面的牌较小即停止，开始插入。

 时间复杂度

以最坏的情况考虑（逆序），外层循环是待进行插入的数，内层循环是比较并插入，即：1+2+3+...+(n-1) 等差数列求和,故为 O(n^2)

但是相较于冒泡排序而言虽然复杂度相同，但是所花费的时间肯定是要更少的。因为冒泡排序是每执行一次将最值移动到最右侧，而每一次的比较是必不可少的，而插入排序实现时，每次待插入牌的前面都是有序的牌，所以并不一定与前面的每一个数都要进行比较，可能中途就已经比较出结果了。

希尔排序

当一个数据是完全逆序的话，插入排序其实也并不比冒泡排序好到哪里去，比方说想要排成升序的话，第一个数是最大的，那每次插入数据时，最大的数都要发生移动，并且是每次移一个位置，所以我们可不可以优化一下插入排序呢，此时名为希尔的人就站了出来。

希尔排序法又称缩小增量法。其实希尔排序就是多次的插入排序，只不过分为预排序和直接排序。而前面了解到了直接排序，而直接排序时是将所有的数都分成一组进行一次排序直接将无序变成有序，即这一组相邻数据之间的差距就为1。但是为了减少不必要的麻烦，所以我们就进行预排序将所有的数据中相邻为gap的分为一组，那么也就有gap组，预排序的效果就是使得原数据接近有序。

预排序

 此时预排序的代码是这样的：

void PreSort(int* a, int n)
{
	int gap = 3, i, j, k;
	for (i = 0; i < gap; i++)//gap组
	{
		for (j = i+gap; j < n; j += gap)//对每一组的插入排序(相邻gap的为一组)
		{
			int tmp = a[j];
			for (k = j-gap; k >=0; k -= gap)
			{
				if (tmp < a[k])
					a[k + gap] = a[k];
				else
					break;
			}
			a[k + gap] = tmp;
		}
	}
}

下面是gap=3时进行一次预排序之后 的结果

 预排序其实就是分组的插入排序，相邻为gap的为一组，将每一组再进行插入排序，这样就可能避免每次插入数据时都要移动数据，并且只移动一位的情况，所以就可以通过分组，每次发生比较移动时移动gap位，这样虽然是看着挺复杂的，但是仔细观察会发现这样移动的次数会大大打折扣。

代码优化一

void PreSort(int* a, int n)
{
	int gap = 3, j, k;

	for (j = gap; j < n; j++)//插入排序(相邻gap的为一组)
	{
		int tmp = a[j];
		for (k = j-gap; k >=0; k -= gap)
		{
			if (tmp < a[k])
				a[k + gap] = a[k];
			else
				break;
		}
		a[k + gap] = tmp;
	}
	
}

这样是不是就少写了一层循环呢，其实只是代码优化了一下，效率其实都是一样的。

优化前其实就是按照分好的组进行一组组的插入排序，而这个就并没有很规矩的按照一组组的来排序，就是从gap后面的数开始插入，但是实质上是一样的，也是按照组别来进行比较插入数据的，简称多组并排。

优化二

其实当gap=1是你会发现不恰好就是直接插入排序嘛，gap越小，每一组的数据间隔也就越小，分的组别也就越少，所以，gap越小时，更大的数就越慢的往后挪动，预排序之后就越接近有序；相反gap越大时，更大的数就越快的往后挪动，预排序之后就越不接近有序。 

所以此时就应该在gap上做文章，从大到小就是好选择，既可以使大的数更大步率地向后移动，也可以使数据越来越接近有序。

void ShellSort(int* a, int n)
{
	int gap = n, i = 0, j = 0, k = 0;
	
	
	while (gap > 1)
	{
		gap = gap / 3 + 1;//使gap越来越小，越来越接近有序，+1为了保证最后一次一定是gap=1(直接插入排序) gap不同分组的情况也不同

		for (j = gap; j < n; j++)//插入排序
		{
			int tmp = a[j];
			for (k = j - gap; k >= 0; k -= gap)//与前面的数(相差gap为一组)一一比较
			{
				if (tmp < a[k])
					a[k + gap] = a[k];//右移
				else
					break;
			}
			a[k + gap] = tmp;
		}
	}

}

第一次gap=n/3+1时就将数据分成了gap组，每一组n/gap个数也就是差不多三个数，虽然看着循环是三层，但是移动数据的次数会大大减少。

排序效率比较

int main()
{
	srand((unsigned int)time(NULL));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	assert(a1 && a2 && a3);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	int begin3 = clock();
	HeapSort(a3, N);
	int end3 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("HeapSort:%d\n", end3 - begin3);

	free(a1);
	free(a2);
	free(a3);
	
	return 0;
}

 这里单位都是毫秒，可以看出希尔排序和堆排序是一个级别的，而堆排序的时间复杂度是O(nlogn)，而据发现希尔排序时间复杂度大约是O(n^1.3)。所以说希尔排序是很