Shellsort: Difference between revisions

Shellsort

Shellsort with gaps 23, 10, 4, 1 in action.
Class	Sorting algorithm
Data structure	Array
Worst-case performance	depends on gap sequence
Best-case performance	depends on gap sequence
Average performance	depends on gap sequence
Worst-case space complexity	O(1)
Optimal	No

Shellsort, also known as Shell sort or Shell's method, is an in-place comparison sort. It generalizes an exchanging sort, such as insertion or bubble sort, by starting the comparison and exchange of elements with elements that are far apart before finishing with neighboring elements. Starting with far apart elements can move some out-of-place elements into position faster than a simple nearest neighbor exchange. Donald Shell published the first version of this sort in 1959.^[1][2] The running time of Shellsort is heavily dependent on the gap sequence it uses. For many practical variants, determining their time complexity remains an open problem.

Shellsort is a multi-pass algorithm. Each pass is an insertion sort of the sequences consisting of every h-th element for a fixed gap h (also known as the increment). This is referred to as h-sorting.

An example run of Shellsort with gaps 5, 3 and 1 is shown below.

${\displaystyle {\begin{array}{rcccccccccccc}&a_{1}&a_{2}&a_{3}&a_{4}&a_{5}&a_{6}&a_{7}&a_{8}&a_{9}&a_{10}&a_{11}&a_{12}\\{\hbox{input data:}}&62&83&18&53&07&17&95&86&47&69&25&28\\{\hbox{after 5-sorting:}}&17&28&18&47&07&25&83&86&53&69&62&95\\{\hbox{after 3-sorting:}}&17&07&18&47&28&25&69&62&53&83&86&95\\{\hbox{after 1-sorting:}}&07&17&18&25&28&47&53&62&69&83&86&95\\\end{array}}}$

The first pass, 5-sorting, performs insertion sort on separate subarrays (a₁, a₆, a₁₁), (a₂, a₇, a₁₂), (a₃, a₈), (a₄, a₉), (a₅, a₁₀). For instance, it changes the subarray (a₁, a₆, a₁₁) from (62, 17, 25) to (17, 25, 62). The next pass, 3-sorting, performs insertion sort on the subarrays (a₁, a₄, a₇, a₁₀), (a₂, a₅, a₈, a₁₁), (a₃, a₆, a₉, a₁₂). The last pass, 1-sorting, is an ordinary insertion sort of the entire array (a₁,..., a₁₂).

As the example illustrates, the subarrays that Shellsort operates on are initially short; later they are longer but almost ordered. In both cases insertion sort works efficiently.

Shellsort is unstable: it may change the relative order of elements with equal values. It has "natural" behavior, in that it executes faster when the input is partially sorted.

Using Marcin Ciura's gap sequence, with an inner insertion sort.

# Sort an array a[0...n-1].
gaps = [701, 301, 132, 57, 23, 10, 4, 1]

foreach (gap in gaps)
    # Do an insertion sort for each gap size.
    for (i = gap; i < n; i += 1)
        temp = a[i]
        for (j = i; j >= gap and a[j - gap] > temp; j -= gap)
            a[j] = a[j - gap]
        a[j] = temp

Every gap sequence that contains 1 yields a correct sort; however, the properties of thus obtained versions of Shellsort may be very different.

The table below compares most proposed gap sequences published so far. Some of them have decreasing elements that depend on the size of the sorted array (N). Others are increasing infinite sequences, whose elements less than N should be used in reverse order.

General term (k ≥ 1)	Concrete gaps	Worst-case time complexity	Author and year of publication
${\displaystyle \lfloor N/2^{k}\rfloor }$	${\displaystyle \left\lfloor {\frac {N}{2}}\right\rfloor ,\left\lfloor {\frac {N}{4}}\right\rfloor ,\ldots ,1}$	${\displaystyle \Theta (N^{2})}$ [when N=2p]	Shell, 1959[1]
${\displaystyle 2\lfloor N/2^{k+1}\rfloor +1}$	${\displaystyle 2\left\lfloor {\frac {N}{4}}\right\rfloor +1,\ldots ,3,1}$	${\displaystyle \Theta (N^{3/2})}$	Frank & Lazarus, 1960[3]
${\displaystyle 2^{k}-1}$	${\displaystyle 1,3,7,15,31,63,\ldots }$	${\displaystyle \Theta (N^{3/2})}$	Hibbard, 1963[4]
${\displaystyle 2^{k}+1}$, with 1 prepended	${\displaystyle 1,3,5,9,17,33,65,\ldots }$	${\displaystyle \Theta (N^{3/2})}$	Papernov & Stasevich, 1965[5]
successive numbers of the form ${\displaystyle 2^{p}3^{q}}$	${\displaystyle 1,2,3,4,6,8,9,12,\ldots }$	${\displaystyle \Theta (N\log ^{2}N)}$	Pratt, 1971[6]
${\displaystyle (3^{k}-1)/2}$, not greater than ${\displaystyle \lceil N/3\rceil }$	${\displaystyle 1,4,13,40,121,\ldots }$	${\displaystyle \Theta (N^{3/2})}$	Knuth, 1973[7]
${\displaystyle \prod \limits _{\scriptscriptstyle 0\leq q<r \atop \scriptscriptstyle q\neq (r^{2}+r)/2-k}a_{q},{\hbox{where}}}$ ${\displaystyle r=\left\lfloor {\sqrt {2k+{\sqrt {2k}}}}\right\rfloor ,}$ ${\displaystyle a_{q}=\min\{n\in \mathbb {N} \colon n\geq (5/2)^{q+1},}$ ${\displaystyle \forall p\colon 0\leq p<q\Rightarrow \gcd(a_{p},n)=1\}}$	${\displaystyle 1,3,7,21,48,112,\ldots }$	${\displaystyle O(Ne^{\sqrt {8\ln(5/2)\ln N}})}$	Incerpi & Sedgewick, 1985[8]
${\displaystyle 4^{k}+3\cdot 2^{k-1}+1}$, with 1 prepended	${\displaystyle 1,8,23,77,281,\ldots }$	${\displaystyle O(N^{4/3})}$	Sedgewick, 1986[9]
${\displaystyle 9(4^{k-1}-2^{k-1})+1,4^{k+1}-6\cdot 2^{k}+1}$	${\displaystyle 1,5,19,41,109,\ldots }$	${\displaystyle O(N^{4/3})}$	Sedgewick, 1986[9]
${\displaystyle h_{k}=\max \left\{\left\lfloor 5h_{k-1}/11\right\rfloor ,1\right\},h_{0}=N}$	${\displaystyle \left\lfloor {\frac {5N}{11}}\right\rfloor ,\left\lfloor {\frac {5}{11}}\left\lfloor {\frac {5N}{11}}\right\rfloor \right\rfloor ,\ldots ,1}$	?	Gonnet & [[Ricardo Baeza-Yates|Template:J]], 1991[10]
${\displaystyle \left\lceil {\frac {9^{k}-4^{k}}{5\cdot 4^{k-1}}}\right\rceil }$	${\displaystyle 1,4,9,20,46,103,\ldots }$	?	Tokuda, 1992[11]
unknown	${\displaystyle 1,4,10,23,57,132,301,701}$	?	Ciura, 2001[12]

When the binary representation of N contains many consecutive zeroes, Shellsort using Shell's original gap sequence makes Θ(N²) comparisons in the worst case. For instance, this case occurs for N equal to a power of two when elements greater and smaller than the median occupy odd and even positions respectively, since they are compared only in the last pass.

Although it has higher complexity than the O(NlogN) that is optimal for comparison sorts, Pratt's version lends itself to sorting networks and has the same asymptotic gate complexity as Batcher's bitonic sorter.

Gonnet and Baeza-Yates observed that Shellsort makes the fewest comparisons on average when the ratios of successive gaps are roughly equal to 2.2.^[10] This is why their sequence with ratio 2.2 and Tokuda's sequence with ratio 2.25 prove efficient. However, it is not known why this is so. Sedgewick recommends to use gaps that have low greatest common divisors or are pairwise coprime.^[13]

With respect to the average number of comparisons, the best known gap sequences are 1, 4, 10, 23, 57, 132, 301, 701 and similar, with gaps found experimentally. Optimal gaps beyond 701 remain unknown, but good results can be obtained by extending the above sequence according to the recursive formula ${\displaystyle h_{k}=\lfloor 2.25h_{k-1}\rfloor }$.

Tokuda's sequence, defined by the simple formula ${\displaystyle h_{k}=\lceil h'_{k}\rceil }$, where ${\displaystyle h'_{k}=2.25h'_{k-1}+1}$, ${\displaystyle h'_{1}=1}$, can be recommended for practical applications.

The following property holds: after h₂-sorting of any h₁-sorted array, the array remains h₁-sorted.^[14] Every h₁-sorted and h₂-sorted array is also (a₁h₁+a₂h₂)-sorted, for any nonnegative integers a₁ and a₂. The worst-case complexity of Shellsort is therefore connected with the Frobenius problem: for given integers h₁,..., h_n with gcd = 1, the Frobenius number g(h₁,..., h_n) is the greatest integer that cannot be represented as a₁h₁+ ... +a_nh_n with nonnegative integer a₁,..., a_n. Using known formulae for Frobenius numbers, we can determine the worst-case complexity of Shellsort for several classes of gap sequences.^[15] Proven results are shown in the above table.

With respect to the average number of operations, none of proven results concerns a practical gap sequence. For gaps that are powers of two, Espelid computed this average as ${\displaystyle 0.5349N{\sqrt {N}}-0.4387N-0.097{\sqrt {N}}+O(1)}$.^[16] Knuth determined the average complexity of sorting an N-element array with two gaps (h, 1) to be ${\displaystyle 2N^{2}/h+{\sqrt {\pi N^{3}h}}}$.^[7] It follows that a two-pass Shellsort with h = Θ(N^1/3) makes on average O(N^5/3) comparisons. Yao found the average complexity of a three-pass Shellsort.^[17] His result was refined by Janson and Knuth:^[18] the average number of comparisons made during a Shellsort with three gaps (ch, cg, 1), where h and g are coprime, is ${\displaystyle {\frac {N^{2}}{4ch}}+O(N)}$ in the first pass, ${\displaystyle {\frac {1}{8g}}{\sqrt {\frac {\pi }{ch}}}(h-1)N^{3/2}+O(hN)}$ in the second pass and ${\displaystyle \psi (h,g)N+{\frac {1}{8}}{\sqrt {\frac {\pi }{c}}}(c-1)N^{3/2}+O((c-1)gh^{1/2}N)+O(c^{2}g^{3}h^{2})}$ in the third pass. ψ(h, g) in the last formula is a complicated function asymptotically equal to ${\displaystyle {\sqrt {\frac {\pi h}{128}}}g+O(g^{-1/2}h^{1/2})+O(gh^{-1/2})}$. In particular, when h = Θ(N^7/15) and g = Θ(h^1/5), the average time of sorting is O(N^23/15).

Based on experiments, it is conjectured that Shellsort with Hibbard's and Knuth's gap sequences runs in O(N^5/4) average time,^[7] and that Gonnet and Baeza-Yates's sequence requires on average 0.41NlnN(ln lnN+1/6) element moves.^[10] Approximations of the average number of operations formerly put forward for other sequences fail when sorted arrays contain millions of elements.

The graph below shows the average number of element comparisons in various variants of Shellsort, divided by the theoretical lower bound, i.e. log₂N!, where the sequence 1, 4, 10, 23, 57, 132, 301, 701 has been extended according to the formula ${\displaystyle h_{k}=\lfloor 2.25h_{k-1}\rfloor }$.

Applying the theory of Kolmogorov complexity, Jiang, Li, and Vitányi proved the following lower bounds for the order of the average number of operations in an m-pass Shellsort: Ω(mN^1+1/m) when m≤log₂N and Ω(mN) when m>log₂N.^[19] Therefore Shellsort has prospects of running in an average time that asymptotically grows like NlogN only when using gap sequences whose number of gaps grows in proportion to the logarithm of the array size. It is, however, unknown whether Shellsort can reach this asymptotic order of average-case complexity, which is optimal for comparison sorts.

The worst-case complexity of any version of Shellsort is of higher order: Plaxton, Poonen, and Suel showed that it grows at least as rapidly as Ω(N(logN/log logN)²).^[20]

Shellsort is now rarely used in serious applications. It performs more operations and has higher cache miss ratio than quicksort. However, since it needs relatively short code and does not use the call stack, some implementations of the qsort function in the C standard library targeted at embedded systems use it instead of quicksort. Shellsort is, for example, used in the uClibc library.^[21] For similar reasons, an implementation of Shellsort is present in the Linux kernel.^[22]

Shellsort can also serve as a sub-algorithm of introspective sort, to sort short subarrays and to prevent a pathological slowdown when the recursion depth exceeds a given limit. This principle is employed, for instance, in the bzip2 compressor.^[23]

• Comb sort

• Knuth, Donald E. (1997). "Shell's method". The Art of Computer Programming. Volume 3: Sorting and Searching (2nd ed.). Reading, Massachusetts: Addison-Wesley. pp. 83–95. ISBN 0-201-89685-0.
• Analysis of Shellsort and Related Algorithms, Robert Sedgewick, Fourth European Symposium on Algorithms, Barcelona, September 1996.

The Wikibook Algorithm implementation has a page on the topic of: Shell sort

• Shellsort with gaps 5, 3, 1 as a Hungarian folk dance

Template:Link GA