希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。 希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

1. 算法步骤

  1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
  2. 按增量序列个数 k，对序列进行 k 趟排序；
  3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

2. JavaScript 代码实现

  1.   1. function shellSort(arr) {
  2.     2.     var len = arr.length,
  3.     3.         temp,
  4.     4.         gap = 1;
  5.     5.     while(gap < len/3) {          //动态定义间隔序列
  6.     6.         gap =gap*3+1;
  7.     7.     }
  8.     8.     for (gap; gap > 0; gap = Math.floor(gap/3)) {
  9.     9.         for (var i = gap; i < len; i++) {
  10.     10.             temp = arr[i];
  11.     11.             for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
  12.     12.                 arr[j+gap] = arr[j];
  13.     13.             }
  14.     14.             arr[j+gap] = temp;
  15.     15.         }
  16.     16.     }
  17.     17.     return arr;
  18.     18. }

3. Python 代码实现

  1.   1. def shellSort(arr):
  2.     2.     import math
  3.     3.     gap=1
  4.     4.     while(gap < len(arr)/3):
  5.     5.         gap = gap*3+1
  6.     6.     while gap > 0:
  7.     7.         for i in range(gap,len(arr)):
  8.     8.             temp = arr[i]
  9.     9.             j = i-gap
  10.     10.             while j >=0 and arr[j] > temp:
  11.     11.                 arr[j+gap]=arr[j]
  12.     12.                 j-=gap
  13.     13.             arr[j+gap] = temp
  14.     14.         gap = math.floor(gap/3)
  15.     15.     return arr
  16.     16. }

4. Go 代码实现

  1.   1. func shellSort(arr []int) []int {
  2.     2.     length := len(arr)
  3.     3.     gap := 1
  4.     4.     for gap < gap/3 {
  5.     5.         gap = gap*3 + 1
  6.     6.     }
  7.     7.     for gap > 0 {
  8.     8.         for i := gap; i < length; i++ {
  9.     9.             temp := arr[i]
  10.     10.             j := i - gap
  11.     11.             for j >= 0 && arr[j] > temp {
  12.     12.                 arr[j+gap] = arr[j]
  13.     13.                 j -= gap
  14.     14.             }
  15.     15.             arr[j+gap] = temp
  16.     16.         }
  17.     17.         gap = gap / 3
  18.     18.     }
  19.     19.     return arr
  20.     20. }

5. Java 代码实现

  1.   1. public class ShellSort implements IArraySort {
  2.     2.   3.     @Override
  3.     4.     public int[] sort(int[] sourceArray) throws Exception {
  4.     5.         // 对 arr 进行拷贝，不改变参数内容
  5.     6.         int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  6.     7.   8.         int gap = 1;
  7.     9.         while (gap < arr.length/3) {
  8.     10.             gap = gap * 3 + 1;
  9.     11.         }
  10.     12.   13.         while (gap > 0) {
  11.     14.             for (int i = gap; i < arr.length; i++) {
  12.     15.                 int tmp = arr[i];
  13.     16.                 int j = i - gap;
  14.     17.                 while (j >= 0 && arr[j] > tmp) {
  15.     18.                     arr[j + gap] = arr[j];
  16.     19.                     j -= gap;
  17.     20.                 }
  18.     21.                 arr[j + gap] = tmp;
  19.     22.             }
  20.     23.             gap = (int) Math.floor(gap / 3);
  21.     24.         }
  22.     25.   26.         return arr;
  23.     27.     }
  24.     28. }

6. PHP 代码实现

  1.   1. function shellSort($arr)
  2.     2. {
  3.     3.     $len = count($arr);
  4.     4.     $temp = 0;
  5.     5.     $gap = 1;
  6.     6.     while($gap < $len / 3) {
  7.     7.         $gap = $gap * 3 + 1;
  8.     8.     }
  9.     9.     for ($gap; $gap > 0; $gap = floor($gap / 3)) {
  10.     10.         for ($i = $gap; $i < $len; $i++) {
  11.     11.             $temp = $arr[$i];
  12.     12.             for ($j = $i - $gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {
  13.     13.                 $arr[$j+$gap] = $arr[$j];
  14.     14.             }
  15.     15.             $arr[$j+$gap] = $temp;
  16.     16.         }
  17.     17.     }
  18.     18.     return $arr;
  19.     19. }

整理人：豆包AI助手