Shell Sort

• This sort was invented by Donald Shell.
• It is better than O(n²), and was the first such sort.
• Idea:
  • Insertion sort is good if the data is mostly ordered.
  • So move data many places in the beginning to get the data mostly ordered
  • Then call insertion sort to finish the job.
• This is called a diminishing increment sort

  ShellSort(A, size)
  
   for gap<- size/2 to 1  do
      for i<- gap to  size do
         tmp <- A[i]
         j <- i;
         while  j ≥ gap and tmp < A[j-gap]
             A[j] <- A[j-gap]
             j <- j - gap
         A[j= <- tmp;
         i <- i + 1
    gap <- gap / 2
  
  

   gap i  j tmp          arary
                    8 3 5 6 7 2 4 1
    4  4  4  7      8 3 5 6 8 2 4 1
       4  0  7      7 3 5 6 8 2 4 1
       5  5  2      7 3 5 6 8 3 4 1
       5  1  2      7 2 5 6 8 3 4 1
       6  6  4      7 2 5 6 8 3 5 1
       6  2  4      7 2 4 6 8 3 5 1
       7  7  1      7 2 4 6 8 3 5 6
       7  3  1      7 2 4 1 8 3 5 6
    2  2  2  4      7 2 7 1 8 3 5 6
       2  0  4      4 2 7 1 8 3 5 6
       3  3  1      4 2 7 2 8 3 5 6
       3  1  1      4 1 7 2 8 3 5 6
       4  4  8      4 1 7 2 8 3 5 6
       5  5  3      4 1 7 2 8 3 5 6
       6  6  5      4 1 7 2 8 3 8 6
       6  4  5      4 1 7 2 7 3 8 6
       6  2  5      4 1 5 2 7 3 8 6
       7  7  6      4 1 5 2 7 3 8 6
    1  1  1  1      4 4 5 2 7 3 8 6
       1  0  1      1 4 5 2 7 3 8 6
       2  2  5      1 4 5 2 7 3 8 6
       3  3  2      1 4 5 5 7 3 8 6
       3  2  2      1 4 4 5 7 3 8 6
       3  1  2      1 2 4 5 7 3 8 6
       4  4  7      1 2 4 5 7 3 8 6
       5  5  3      1 2 4 5 7 7 8 6
       5  4  3      1 2 4 5 5 7 8 6
       5  3  3      1 2 4 4 5 7 8 6
       5  2  3      1 2 3 4 5 7 8 6
       6  6  8      1 2 3 4 5 7 8 6
       7  7  6      1 2 3 4 5 7 8 8
       7  6  6      1 2 3 4 5 7 7 8
       7  5  6      1 2 3 4 5 6 7 8
  

• Notice that after each outer loop we have list of sorted lists.

      gap    
       4      7 2 4 1 8 3 5 6
       2      4 1 5 2 7 3 8 6
       1      1 2 3 4 5 6 7 8
  

• Each of the above lists is said to be k-sorted, in this case :4-sorted, 2-sorted, 1-sorted.
• As the gap diminishes, the list remains k-sorted for higher values of k.
• Thus the 2-sorted list is also 4-sorted.
• Shell proposed the gap sequence of 1, 2, 4, ...
• It turns out that this selection for sequences of gap yields an O(n²) sort.
• The problem is that the sequence of gaps are multiples of each other, and thus do not have the optimal effect for each pass.
• If they were relatively prime, then more work would be done on each pass.
• A better choice of gap sequences is 1, 3, 7, 15, ... 2^k-1 was proposed by Hibbard.
• This yields a sort that is O(n^3/2), but this is difficult to prove.

   gap i  j tmp          arary
                    8 3 5 6 7 2 4 1
    7  7  7  1      8 3 5 6 7 2 4 8
       7  0  1      1 3 5 6 7 2 4 8
    3  3  3  6      1 3 5 6 7 2 4 8
       4  4  7      1 3 5 6 7 2 4 8
       5  5  2      1 3 5 6 7 5 4 8
       5  2  2      1 3 2 6 7 5 4 8
       6  6  4      1 3 2 6 7 5 6 8
       6  3  4      1 3 2 4 7 5 6 8
       7  7  8      1 3 2 4 7 5 6 8
    1  1  1  3      1 3 2 4 7 5 6 8
       2  2  2      1 3 3 4 7 5 6 8
       2  1  2      1 2 3 4 7 5 6 8
       3  3  4      1 2 3 4 7 5 6 8
       4  4  7      1 2 3 4 7 5 6 8
       5  5  5      1 2 3 4 7 7 6 8
       5  4  5      1 2 3 4 5 7 6 8
       6  6  6      1 2 3 4 5 7 7 8
       6  5  6      1 2 3 4 5 6 7 8
       7  7  8      1 2 3 4 5 6 7 8
  

• Further work has reduced the complexity to at least O(n^4/3) or better for other sequences.