/*@ requires \valid(t + (l..r));
requires r >= 0;
requires l >= 0;
decreases r - l;
assigns t[l..r];
ensures Sorted(t, l, r + 1);
ensures Permut{Old,Here}(t, l, r);
*/
void quick_rec(int t[], int l, int r)
{
int v, m, i;
if (l >= r) return;
v = t[l];
m = l;
/*@ loop invariant
\forall integer j; l < j <= m ==> t[j] < v;
loop invariant
\forall integer j; m < j < i ==> t[j] >= v;
loop invariant
Permut{Pre,Here}(t, l, r);
loop invariant t[l] == v && l <= m < i <= r + 1;
loop variant r - i;
*/
for (i = l + 1; i <= r; i++) {
if (t[i] < v) {
L1: sort_swap(t, i, ++m);
//@ assert Permut{L1,Here}(t, l, r);
}
}
//@ assert l <= m <= r;
L: sort_swap(t, l, m);
//@ assert Permut{L,Here}(t, l, r);
quick_rec(t, l, m - 1);
quick_rec(t, m + 1, r);
}
void shell_sort(int *tabl, int size)
{
for (int i = size / 2; i > 0; i /= 2)
for (int j = i; j < size; j++)
for (int k = j - i; k >= 0; k -= i)
if (tabl[k + i] >= tabl[k])
break;
else
sort_swap(tabl, k, k + i);
}
void do_heap_sort(int *tabl, int n, int k, int tabl_size)
{
int i;
int j;
while (tabl_size--)
{
sort_swap(tabl, 0, tabl_size);
for (n = 0; (i = (2 * n) + 1) < tabl_size; n = k)
{
j = i + 1;
if (j < tabl_size && tabl[i] < tabl[j])
k = j;
else
k = i;
if (tabl[n] < tabl[k])
sort_swap(tabl, n, k);
else
break ;
}
}
}
void heap_sort(int *tabl, int size)
{
int n;
int k;
int tabl_size;
int tmp;
for (tabl_size = 1; tabl_size < size; tabl_size++)
{
for (n = tabl_size; n; n = k)
{
k = (n - 1) / 2;
if (tabl[n] > tabl[k])
sort_swap(tabl, n, k);
else
break ;
}
}
do_heap_sort(tabl, n, k, tabl_size);
}
