希尔排序 Java

希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，

因DL．Shell于1959年提出而得名。

 原文取自： http://baike.baidu.com/view/2217047.htm

                  http://blog.163.com/xiaopengyan_109/blog/static/149832173201061642815541/

希尔排序基本思想：

　　先取一个小于n的整数d1作为第一个 增量 ，把文件的全部记录分成（n除以d1）个组。

所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，

取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，

即所有记录放在同一组中进行直接插入排序为止。

　　该方法实质上是一种分组插入方法。

　　给定实例的shell排序的排序过程

　　假设待排序文件有10个记录，其关键字分别是：

　　49，38，65，97，76，13，27，49，55，04。

　　增量序列的取值依次为：

　　5，3，1

缩小增量法

　　属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序

　　排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；

然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止

　　初始：d=5

　　49 38 65 97 76 13 27 49 55 04

　　49 13

　　|-------------------|

　　38 27

　　|-------------------|

　　65 49*

　　|-------------------|

　　97 55

　　|-------------------|

　　76 04

　　|-------------------|

　　一趟结果

　　13 27 49* 55 04 49 38 65 97 76

　　d=3

　　13 27 49* 55 04 49 38 65 97 76

　　13 55 38 76

　　|------------|------------|------------|

　　27 04 65

　　|------------|------------|

　　49* 49 97

　　|------------|------------|

　　二趟结果

　　13 04 49* 38 27 49 55 65 97 76

　　d=1

　　13 04 49* 38 27 49 55 65 97 76

　　|----|----|----|----|----|----|----|----|----|

　　三趟结果

　　04 13 27 38 49 49 55 65 76 97

算法思想简单描述：

　　在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。

　　不需要大量的辅助空间，和归并排序一样容易实现。希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度为 O(N*(logN)2)， 没有快速排序算法快 O(N*(logN))，因此中等大小规模表现良好，对规模非常大的数据排序不是 最优选择。但是比O(N2）复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏 的情况下执行的效率会非常差。 专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快， 再改成快速排序这样更高级的排序算法. 本质上讲，希尔排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当N值很大时数据项每一趟排序需要的个数很少，但数据项的距离很长。 当N值减小时每一趟需要和动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比插入排序高很多。

时间性能

　　1．增量序列的选择

　　Shell排序的执行时间依赖于增量序列。

　　好的增量序列的共同特征：

　　① 最后一个增量必须为1；

　　② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。

　　有人通过大量的实验，给出了目前较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。

　　2．Shell排序的时间性能优于直接插入排序

　　希尔排序的时间性能优于直接插入排序的原因：

　　①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。

　　②当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。

　　③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。

　　因此，希尔排序在效率上较直接插人排序有较大的改进。

稳定性

　　 排序前一个序列中,如果出现N个与关键字相同的数据,那么排序后仍然按照原先序列的排列顺序排列,就说这个算法是稳定的,反之就是不稳定的。通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

　　希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

　 Java的代码实现（代码有改动）

说明：    

          代码1是我在网上找到的个人觉得比较好的一类希尔排序的方法，代码2是自己想的。

我觉得这两种方法好的原因是都有 while（h < array.length / 3) h = h *3 + 1;和 h =  (h - 1) / 3;

这种随着数组长度可以随时将参数变化，比较灵活。

        下面的代码运行速度相比，代码2 比代码1 少用 1或0 毫秒（千分之一秒）如果将两个代码中的语句

 while（h < array.length / 3) h = h *3 + 1;和 h =  (h - 1) / 3;换成 while（h < array.length / 2) h = h *2 + 1;和 h =  (h - 1) / 2; 当前数组量来说，代码2的执行速度会比代码1的执行速度更快了。

     虽然学会这这种算法没什么，但这还是让我非常有满足感。大大的过瘾。

===========================================================================

代码1：

public class MyShellSort2
{
	public static void main(String[] args)
	{
	    long begin = System.currentTimeMillis();
	    
		int[] a = new int[10000];
//		System.out.print("排序前： ");
		for (int i = 0; i < 10000; i++)
		{
			a[i] = (int) (Math.random() * 100);
//			System.out.print(a[i] + " ");
		}
//		System.out.println();

		int h = 1;
		int temp;
		int inner;

		// 希尔排序
		while (h <= a.length / 3)
			h = h * 3 + 1;

		while (h > 0)
		{
			for (int i = h; i < a.length; i++)
			{
				temp = a[i];
				inner = i;
				
				while (inner >= h && a[inner - h] > temp)
				{
					a[inner] = a[inner - h];
					inner -= h;
				}
				
				a[inner] = temp;
			}
			
//			System.out.println("h = " + h + " , " + "sorted: ");
//			for(int i = 0; i < a.length; i++)
//			{
//				System.out.print(a[i] + "  ");
//			}
//			System.out.println();
			
			h = (h - 1) / 3;
		}

//		System.out.print("排序后： ");

//		for (int i = 0; i < a.length; i++)
//		{
//			System.out.print(a[i] + " ");
//		}
		
		long finish = System.currentTimeMillis();
		
		System.out.println(finish - begin);
		

	}
}

代码2：

public class MyShellSort3
{
	public static void main(String[] args)
	{
		long begin = System.currentTimeMillis();
		
		int[] a = new int[10000];
//		System.out.print("排序前： ");
		for (int i = 0; i < 10000; i++)
		{
			a[i] = (int) (Math.random() * 100);
//			System.out.print(a[i] + " ");
		}
//		System.out.println();

		int h = 1;
		int temp;
		int inner;

		// 希尔排序
		while (h <= a.length / 3)
			h = h * 3 + 1;

		while (h > 0)
		{
			straightInsertionSort(a, h);

//			System.out.println("h = " + h + " , " + "sorted: ");

//			for (int i = 0; i < a.length; i++)
//			{
//				System.out.print(a[i] + " ");
//			}
			
//			System.out.println();

			h = (h - 1) / 3;
		}

//		System.out.print("排序后： ");

//		for (int i = 0; i < a.length; i++)
//		{
//			System.out.print(a[i] + " ");
//		}
		
		long finish = System.currentTimeMillis();
		
		System.out.println(finish - begin);
	}

	private static void straightInsertionSort(int[] array, int h)
	{
		
		for(int i = 0; i < h; i ++)
		{
			straightSort(array, i, h);
		}
	}
	
	private static void straightSort(int[] array, int a, int h)
	{
		int j;

		for (int i = a; i < array.length; i += h)
		{
			int temp = array[i];

			for (j = i; j >= a && j >= h && temp < array[j - h]; j -= h)
			{
				array[j] = array[j - h];
			}

			array[j] = temp;
		}
	}
}

===========================================================================

当然如果有什么失误的地方还是请热心人指正。