排序之希尔排序

希尔排序是基于插入排序的快速的排序算法。插入排序对于大规模乱序数组插入排序很慢，因为他只会交换相邻的元素，因此元素只能一点一点从数组的一端一到另一端。希尔排序为了加快速度简单的改进了插入排序，交换不相邻的元素以对数组的局部进行排序，并最终将局部有序的数据排序。

 

希尔排序的思想是使数组中任意间隔为h的元素都是有序的。一个h有序数组就是h个互相独立的有序数组交织在一起组成的一个数组。在进行排序时，如果h很大，我们就能将元素移动到很远的地方，为实现更小的h有序创造方便。用这种方式，对于任意以1结尾的h序列，都能够将数组排序。

         h= 4

         L       E       E       A       M     H      L       E       P       S       O      L       T       S       X       R

         L                                   M                                 P                                   T

                   E                                   H                                  S                                   S

                            E                                   L                                   O                                  X

                                     A                                   E                                   L                                   R

实例:

初始h = 2

         5                          20                       15                       30                       2

         5                                                      15                                                   2

                                     20                                                   30

         一趟排序后，序列为： 2     20     5       30     15

h = 1

         2                          20                       5                          30                       15

         第二次排序后，序列为：2  5       15     20     30

 

代码：

/*

	name:希尔排序
	author:adtim

*/
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>


void xesort(std::vector<int> &vec); // 希尔排序主程序
void swap(int &a, int &b); // 交换
int less(int a, int b); // 小于
int main()
{
	std::vector<int> vec = {0, 3,23,12,1,123,34}; // 待排序数组。
	xesort(vec);
	for (auto tmp : vec)
		std::cout << tmp << " ";
	std::cout << std::endl;
	system("pause");
	return EXIT_SUCCESS;
}

void xesort(std::vector<int> &vec)
{
	int length = vec.size();
	int h = length / 2;
	while (h >= 1)
	{
		for (int i = h; i < length; i++)
		{
			for (int j = i; j >= h && less(vec[j], vec[j - h]); j -= h) // j>=h 保证j-h>=0;
			{
				swap(vec[j], vec[j - h]);
			}
		}
		h /= 2;
	}
}

void swap(int &a, int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int less(int a, int b)
{
	return a < b;
}