希尔排序（java实现，简单易懂）

希尔排序

希尔排序*是插入排序的一种比较高级的改进算法，整体结构的核心算法还是插入排序，希尔排序是对一个整体需要排序的数组进行“间隔”的排序，而这个“间隔”的选取也在一定程度上决定了证程序的时间复杂度，即程序的性能。

下面我们就采用间隔为arr.length/2为例进行分析，例如一个随机长度是为15的数组，int[] arr = {9,6,11,3,5,12,8,7,10,15,14,4,1,13,2};当我们采用间n= arr.length/2=7为长度进行排序时，当间隔为n=7时排序完应该是 2 6 11 3 4 1 8 7 10 15 14 5 12 13 9 ,间隔每次除以2，n=3再次排序，应该为：1 5 2 3 6 4 8 7 10 9 13 11 15 14 12 ，同理，最后一次n=1排序为：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15，整体就排序好了。

当采用Knuth序列uth序列时，结果一样，性能略好些，下面将测试代码附上：

import java.util.Random;
/*
 * 在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
   然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。
  是插入排序的一种改进算法
  Knuth序列 h=1, h=3*n+1;   或者是n/2序列    时间复杂度都不相同
 */
public class ShellSort {
	public static void main(String[] args) {
		int[] arr = new int[1800];
		Random r = new Random();
		for(int i =0 ;i<1800;i++) {
		arr[i] = r.nextInt(1000000);
		}
		//int[] arr = {9,6,11,3,5,12,8,7,10,15,14,4,1,13,2};
		sort(arr);
		print(arr);
		sort1(arr);
		print(arr);
	}

	public static void print(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println(arr[arr.length-1]);
	}
    //1.第二种是以n/2作为间隔
	public static void sort(int[] arr) {
		long start = System.currentTimeMillis();
		for(int value = arr.length/2; value>0;value/=2) {
		  for(int i=value;i<arr.length;i++) {
			for(int j=i;j>value-1;j-=value) {
				if(arr[j-value]>arr[j]) {
					int temp = arr[j];
					arr[j] = arr[j-value];
					arr[j-value] = temp;
				}
			}
		}
	 }
		long end = System.currentTimeMillis();
		System.out.println(end-start);
   }
	//2.第二种采用Knuth序列，利用h=3*h+1作为间隔
	public static void sort1(int[] arr) {
		long start = System.currentTimeMillis();
		for(int value = arr.length/3;value>0;value=(value/3)-1) {
			for(int i=value;i<arr.length;i++) {
				for(int j=i;j>value-1;j-=value) {
					if(arr[j-value]>arr[j]) {
						int temp = arr[j];
						arr[j] = arr[j-value];
						arr[j-value] = temp;
					}
				}
			}
		}
		long end = System.currentTimeMillis();	
		System.out.println(end-start);
	}
}

采用不同的“间隔”性能略有不同，但是整体的性能比插入排序要好，时间复杂度约为n^1.5,下图是我测试的1800个数据所用的时间相比

可见Knuth序列性能略好些。