希尔排序

希尔排序又称为缩小增量排序，它的基本思想是：设排序表中有n个数据元素，首先取一个整数d<n作为间隔，将全部数据元素分为d个子表，所有相距为d的数据元素放在同一个子表中，在每个子表中分别进行直接插入排序，然后缩小间隔d（例如取d=ceil(d/2)，ceil为向上取整），重复上述的子表划分和排序工作。如此循环，直到最后d=1，将所有数据元素放在同一个序列中进行直接插入排序。

看一个例子，排序表有6个数据元素，d取3，说明有3个子表，第二趟d=ceil(d/2)=2，第三趟d=ceil(d/2)=1。

希尔排序过程

	0	1	2	3	4	5	d
初始序列	46	31	6	19	23	31*
第一趟	46			19			3
		31			23
			6			31*
结果	19	23	6	46	31	31*
第二趟	19		6		31		2
		23		46		31
结果	6	23	19	31*	31	46
第三趟	6	23	19	31*	31	46	1
结果	6	19	23	31*	31	46

下面是代码实现：

public class App 
{
	
	public static void main(String[] arg) {
		int[] array= {46,31,6,19,23,31};
//		shellSort(array, 3);
		shellSort2(array);
		System.out.println(Arrays.toString(array));
		

	}

	static void shellSort(int[] array,int d) {
		if(d>=array.length) {
			throw new RuntimeException("d cann't equal or great than length of array ");
		}
		boolean flag=false;//函数结束标志位
		while(true) {//每一趟排序，每趟共d个子表
			for(int i=0;i<d;i++) {
				//为每个子表排序
				int first=i;
//				if(first>array.length-1)break;//如果没有下一个要插入的元素，则表明这个子表排序完成
				for(int j=first+d;j<array.length;j=j+d) {
					int temp=array[j];
					int x=j-d;
					while(x>=first && array[x]>temp) {
						array[x+d]=array[x];
						x=x-d;
					}
					array[x+d]=temp;
				}
			}
			
			//当d=1时，进行最后一趟排序，然后退出
			if(flag)return;
			d=(int)Math.ceil(d/2.0);
			flag=d==1;
		}
	}
	
	static void shellSort2(int[] array) {
		int temp;
		int d=array.length/2;
		int j;
		while(d!=0) {
			for(int i=d;i<array.length;i++) {
				temp=array[i];
				for( j=i;j>=d;j-=d) {
					if(temp<array[j-d]) {
						array[j]=array[j-d];
					}else {
						break;
					}
				}
				array[j]=temp;
			}
			d=(int)d/2;
		}
	}

}

第一个shellSort函数是我自己写的，感觉有点复杂，但是和上述例子的结果是一致的，执行了三趟。

第二个shellSort2函数是书上的算法过程，书上的代码就是间接，我的代码把每个子表的排序分开了，而shellSort2却是没有明确划分子表的界限，实在高明。。

讨论下为什么希尔排序速度比较快。我前面的文章给出了直接插入排序和折半插入排序。而直接插入排序是希尔排序的基础，直接插入排序有一个特点，就是初始数据表越接近有序，排序效率就越高。因此，开始d取值较大，每个子表的数据元素很小，即使初始顺序比较乱，直接插入排序也比较快。到排序的后期，d取值很小了，子表的数据元素逐渐变多，但是由于前面的工作，大多数数据元素基本有序了，所以直接插入排序速度仍然很快。

上面的解释只是一个角度，接下来从另一个角度来解读。在希尔排序过程中，逆序的数据元素不是一步一步地而是跳跃式地（按间隔d）向正序方向移动。这就意味着数据元素的移动次数和关键字的比较次数将会减少，所以希尔效率应该是比较高的。拿冒泡排序来说，遇到逆序的数据时都是相邻的两个数据元素之间交换，因此数据元素的移动的较慢，而希尔确实跳跃式地移动。

希尔排序复杂度的分析很困难，但是有人通过大量实验统计得出，当n很大时，关键字平均比较次数和数据元素平均移动次数大约在n^1.25~1.6n^1.25范围内。因此平均时间复杂度为O(n^1.25)。

希尔排序是不稳定的排序方法。