Java排序算法（七）：希尔排序(Shell排序)

Java排序算法（七）：希尔排序(Shell排序)

希尔排序(缩小增量法) 属于插入类排序,由Shell提出，希尔排序对直接插入排序进行了简单的改进：它通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而使数据项大跨度地移动，当这些数据项排过一趟序之后，希尔排序算法减小数据项的间隔再进行排序，依次进行下去，进行这些排序时的数据项之间的间隔被称为增量，习惯上用字母h来表示这个增量。

常用的h序列由Knuth提出，该序列从1开始，通过如下公式产生：

h = 3 * h +1

反过来程序需要反向计算h序列，应该使用

h=(h-1)/3

 

代码实现：

 

[java]  view plain copy print ?

1. package sort;  
2.   
3. public class ShellSortTest {  
4.     public static int count = 0;  
5.   
6.     public static void main(String[] args) {  
7.   
8.         int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  
9.         print(data);  
10.         shellSort(data);  
11.         print(data);  
12.   
13.     }  
14.   
15.     public static void shellSort(int[] data) {  
16.         // 计算出最大的h值  
17.         int h = 1;  
18.         while (h <= data.length / 3) {  
19.             h = h * 3 + 1;  
20.         }  
21.         while (h > 0) {  
22.             for (int i = h; i < data.length; i += h) {  
23.                 if (data[i] < data[i - h]) {  
24.                     int tmp = data[i];  
25.                     int j = i - h;  
26.                     while (j >= 0 && data[j] > tmp) {  
27.                         data[j + h] = data[j];  
28.                         j -= h;  
29.                     }  
30.                     data[j + h] = tmp;  
31.                     print(data);  
32.                 }  
33.             }  
34.             // 计算出下一个h值  
35.             h = (h - 1) / 3;  
36.         }  
37.     }  
38.   
39.     public static void print(int[] data) {  
40.         for (int i = 0; i < data.length; i++) {  
41.             System.out.print(data[i] + "\t");  
42.         }  
43.         System.out.println();  
44.     }  
45.   
46. }  

运行结果：

[java]  view plain copy print ?

1. 5   3   6   2   1   9   4   8   7     
2. 1   3   6   2   5   9   4   8   7     
3. 1   2   3   6   5   9   4   8   7     
4. 1   2   3   5   6   9   4   8   7     
5. 1   2   3   4   5   6   9   8   7     
6. 1   2   3   4   5   6   8   9   7     
7. 1   2   3   4   5   6   7   8   9     
8. 1   2   3   4   5   6   7   8   9  

上面程序在和直接插入法比较，会发现其与直接插入排序的差别在于：直接插入排序中的h会以1代替

 

Shell排序是不稳定的，它的空间开销也是O(1),时间开销估计在O(N3/2)~O(N7/6)之间