Java与算法之(10) - 希尔排序

希尔排序是插入排序的一种，是直接插入排序的改进版本。

对于上节介绍的直接插入排序法，如果数据原来就已经按要求的顺序排列，则在排序过程中不需要进行数据移动操作，即可得到有序数列。但是，如果最初的数据是按倒序排列的，则在进行插入排序时每次的比较都需要向后移动数据，这样，将导致算法的效率很低。

希尔排序的思想是把数列划分为若干个较小的数列，对每组数列使用直接插入排序算法排序，随着增量逐渐减少，每组包含的数字越来越多，当增量减至1时，整个数列恰被分成一组，最后再使用一次直接插入排序对整个数列进行排序。

例如有4, 3, 6, 2, 7, 1, 5, 8八个数字，第一次分成四组，即8/2组。如下图，相同颜色的数字为一组，下标为x的数字和下标为x+4的数字为一组。

对这四个数组分别做直接插入排序，即两两比较，如果大的在前则交换位置，得到：

然后缩小组数，4/2=2，缩小为两组。如下图：

对这两个数组分别做直接插入排序，得到：

再次缩小组数，2/2=1，缩小为一组，那么所有数字都。如下图：

最后，对4, 1, 5, 2, 6, 3, 7, 8这个数列执行一次直接插入排序。

总结上面的规律，可以得出：

第一次分组数s = n / 2 == 0 ? n / 2 : n / 2 + 1

取数规则是[x]和[x+n/2]为一组

当然，这只是比较简单的分组方式，不一定是最优的。来看代码：

1. public class ShellSort {
2. private int[] numbers;
3. public ShellSort(int[] numbers) {
4. this.numbers = numbers;
5. }
6. /**
7. * 对数组分组并对每个组做直接插入排序, 完成后缩小组的数量, 重复插入排序, 直到缩小到一个组
8. * 第一次分组数: section = n/2 == 0 ? n/2 : n/2+1, 分组规则: 每隔n/2挑一个数, 即[x]和[x+n/2]为一组
9. */
10. public void sort() {
11. int section = this.numbers.length / 2;
12. int j;
13. int temp;
14. while(section >= 1) {
15. for(int i = section; i < this.numbers.length; i++) {
16. temp = this.numbers[i];
17. j = i - section;
18. while(j >= 0 && this.numbers[j] > temp) {
19. this.numbers[j + section] = this.numbers[j];
20. j = j - section;
21. }
22. this.numbers[j + section] = temp;
23. }
24. section /= 2;
25. }
26. System.out.print("排序后: ");
27. for(int x = 0; x < numbers.length; x++) {
28. System.out.print(numbers[x] + "  ");
29. }
30. }
31. public static void main(String[] args) {
32. int[] numbers = new int[] { 4, 3, 6, 2, 7, 1, 5, 8 };
33. System.out.print("排序前: ");
34. for(int x = 0; x < numbers.length; x++) {
35. System.out.print(numbers[x] + "  ");
36. }
37. System.out.println();
38. ShellSort ss = new ShellSort(numbers);
39. ss.sort();
40. }
41. }

运行：

1. 排序前: 4  3  6  2  7  1  5  8
2. 排序后: 1  2  3  4  5  6  7  8

希尔排序的时间复杂度，最坏是O(n^2)，平均O(n^3/2)。