希爾排序（非穩定排序演算法）是基於插入排序的以下兩點性質而提出改進方法的：

• 插入排序在對幾乎已經排好序的資料操作時，效率高，即可以達到線性排序的效率；
• 但插入排序一般來說是低效的，因為插入排序每次只能將資料移動一位；

希爾排序的基本思想是：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄"基本有序"時，再對全體記錄進行依次直接插入排序。

演算法步驟

選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列個數 k，對序列進行 k 趟排序；

每趟排序，根據對應的增量 ti，將待排序列分割成若干長度為 m 的子序列，分別對各子表進行直接插入排序。僅增量因子為 1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

JavaScript

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

Python

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

C語言

 1 void shell_sort(int arr[], int len) {
 2         int gap, i, j;
 3         int temp;
 4         for (gap = len >> 1; gap > 0; gap >>= 1)
 5                 for (i = gap; i < len; i++) {
 6                         temp = arr[i];
 7                         for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
 8                                 arr[j + gap] = arr[j];
 9                         arr[j + gap] = temp;
10                 }
11 }

C++

 1 template<typename T>
 2 void shell_sort(T array[], int length) {
 3     int h = 1;
 4     while (h < length / 3) {
 5         h = 3 * h + 1;
 6     }
 7     while (h >= 1) {
 8         for (int i = h; i < length; i++) {
 9             for (int j = i; j >= h && array[j] < array[j - h]; j -= h) {
10                 std::swap(array[j], array[j - h]);
11             }
12         }
13         h = h / 3;
14     }
15 }