Java基础知识强化57：经典排序之希尔排序（ShellSort）

1. 希尔排序的原理：

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。

在上面这幅图中：

初始时，有一个大小为 10 的无序序列。

在第一趟排序中，我们不妨设 gap1 = N / 2 = 5，即相隔距离为 5 的元素组成一组，可以分为 5 组。

接下来，按照直接插入排序的方法对每个组进行排序。

在第二趟排序中，我们把上次的 gap 缩小一半，即 gap2 = gap1 / 2 = 2 (取整数)。这样每相隔距离为 2 的元素组成一组，可以分为 2 组。

按照直接插入排序的方法对每个组进行排序。

在第三趟排序中，再次把 gap 缩小一半，即gap3 = gap2 / 2 = 1。 这样相隔距离为 1 的元素组成一组，即只有一组。

按照直接插入排序的方法对每个组进行排序。此时，排序已经结束。

需要注意一下的是，图中有两个相等数值的元素 5 和 5 。我们可以清楚的看到，在排序过程中，两个元素位置交换了。（希尔排序的不稳定性）

所以，希尔排序是不稳定的算法。

2. 希尔排序代码实现：

 package cn.itcast;

 /*
  * 希尔排序：先取一个小于n的整数d1作为第一个增量，
  * 把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。
  * 先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，
  * 直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
  */
 public class ShellSort {
     public static void main(int[] data) {
         for (int i = data.length / 2; i > 2; i /= 2) {
             for (int j = 0; j < i; j++) {
                 insertSort(data, j, i);
             }
         }
         insertSort(data, 0, 1);
     }

     /**
      * @param data
      * @param j
      * @param i
      */
     private static void insertSort(int[] data, int start, int inc) {
         for (int i = start + inc; i < data.length; i += inc) {
             for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
                 swap(data, j, j - inc);
             }
         }
     }
     /*
      * 交换数组中的两个元素
      */
     public static void swap(int[] data, int i, int j) {
         int temp = data[i];
         data[i] = data[j];
         data[j] = temp;
     }
 }
 /*
  * 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 　　
  * 排序过程：先取一个正整数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
  */

3. 希尔排序示例代码：

 package com.himi.classicort;

 public class ShellSortDemo {

     public static void main(String[] args) {

         int[] array = new int[] {12, 33, 4, 15, 25, 55, 18};

         System.out.println("希尔排序之前的数组：");
         printArray(array);

         System.out.println();

         System.out.println("希尔排序之后的数组：");
         shellsort(array);
         printArray(array);

     }

     public static void shellsort(int[] array) {
         int d = array.length;
         while (true) {

             for (int i = 0; i < d; i++) {

                 for (int j = i; j + d < array.length; j += d) {
                     int temp;

                     if (array[j] > array[j + d]) {
                         temp = array[j];
                         array[j] = array[j + d];
                         array[j + d] = temp;
                     }
                 }
             }

             if (d == 1) {
                 break;
             }
             d--;
         }

     }

     public static void printArray(int[] array) {

         System.out.print("[");

         int i;
         for(i= 0; i<array.length; i++) {        

             if(i ==array.length-1) {
                 System.out.print(array[i]);
             } else {
                 System.out.print(array[i]+",");
             }
         }
         System.out.print("]");

     }
 }

运行程序，如下：