Shell Sort and Confusion with gaps - algorithm

Question

I've recently seen and studied the shell-sort algorithm and the seen the example provided here. In the example they consider a 'inc' or 'gap'.
I made a c implementation of the algorithm, and taking the gap value as a parameter in the sort.
I am observing the fact that for 10 unsorted values which are :
5, 1, 3, 2, 4, 8, 6, 9, 7, 10
using any gap, I am getting the following output :
1 2 3 4 5 6 8 7 9 10
I've built a recursive version of the code, which is here :
void shellSort(int *arr, int size, int gap){
int i, tmp;
if (gap == 0) return;
for (i = 0; i < size / gap; i+=gap){
if (i < size - 1){//Valid Index
if (arr[i] > arr[i + gap]){
tmp = arr[i];
arr[i] = arr[i + gap];
arr[i + gap] = tmp;
}
}
}
printf("Interation : \n");
for (i = 0; i < 10; i++){
printf("%d\t", arr[i]);
}
printf("\n\n");
shellSort(arr, size, gap - 1);
}
Example :
int main()
{
int arr[] = { 5, 1, 3, 2, 4, 8, 6, 9, 7, 10 }, i;
shellSort(&arr[0], 10, 3);
getch();
return 0;
}
After reading through the material in the internet, I am completely confused about selecting this gap value, in some places like wikipedia, they are using a gap sequence. Some assistance would be appreciated.
After Correction,
for (i = 0; i < size - gap; i++)
Output:
1 3 2 4 5 6 8 7 9 10

Answer 1

This code is not shell sort, it is a kind of comb sort
In this line
for (i = 0; i < size / gap; i+=gap)
index i doesn't walk through the whole array. Possible correction:
for (i = 0; i < size - gap; i++)
For full sorting, you have to repeat sort with gap = 1 while swapping occurs. Examples
Gaps are described in every manual about shellsort or combsort.
In short - two indexes, separated by gap, walk through array, so unordered elements are moving closer to their places in sorted array. After every run gap decreases (in shellsort denominator is 2-3, in combsort - 1.3). Decrementing gap by 1 (as your code shows) makes the code very slow.

Answer 2

In the Shell-Sort Algorithm, you need to understand the concept of gap-sorting an array (or h-sorting).
Assume that you have a gap 'h'. You will begin with the first element tab[0] and sort all the elements spaced by h in your array: tab[0], tab[h], tab[2h] ... then you will pick the secend element as a begining and try to sort the spaced elements. Each time the starting element is incremented. To sort the h-spaced elements, you use the insertion sort algorithm.
After that choose a sequence for your h-insertion sort code starting from the biggest gap.
This is my implementation in java:
// Using Pratt sequence
public static void hSort(int tab[]) {
int N = tab.length;
int k = 0;
int sequence = 1;
// Getting the final term of the pratt sequence
while(((int)(Math.pow(3, k) - 1) / 2) < N/3) {
sequence = (int)(Math.pow(3, k) - 1) / 2;
k++;
}
k--;
while(sequence > 0) {
hInsertionSort(tab, sequence);
k--;
sequence = (int)(Math.pow(3, k) - 1) / 2;
}
}
public static void hInsertionSort(int[] tab, int h) {
int N = tab.length;
int k = 0;
while (k < h) {
for (int i = k; i < N; i+=h) {
for (int j = i; j > k+h-1; j-=h) {
if (less(tab[j], tab[j-h]) == -1) exch(tab, j, j-h);
else break;
}
}
k++;
}
}
private static inttab[1] (it means sort tab[1], tab[h+1], ...). This is h-sorting your array. less(int value1, int value2) {
if (value1 == value2) return 0;
if (value1 < value2) return -1;
else return 1;
}
tab[1] (it means sort tab[1], tab[h+1], ...). This is h-sorting your array.
private static void exch(int[] tab, int key1, int key2) {
int inter;
inter = tab[key1];
tab[key1] = tab[key2];
tab[key2] = inter;
}