Building the min heap using recursion alone - c

Question

This is an attempt to make heapsort building the heap solely with function calls. The problem is that it's taking too long to complete, longer than a simpler bubblesort written in the same project, nearly 100 seconds vs bubble's 42 with 100000 entries in descending order. Mergesort and quicksort never got past a second. Nevermind the fact that it crashes on 100000 if the compiler fails to make a tail-call optimization.
It used to crash, some of the details on the implementations are there to make tail-calls happen. It has been tested on descending, ascending and randomly distributed data. Some of the changes were also made to remedy how slow it was, what gives it it's obfuscated look.
int heap_sort_step(int v[], int len, int i){
int nextl = 2 * i + 1, nextr = nextl + 1;
char bfl = (nextl<len)|((nextr<len)<<1);
switch(bfl)
{
case 3:
case 2:
while(v[i] > heap_sort_step(v, len, nextr))
swap(v + i, v + nextr);
case 1:
while(v[i] > heap_sort_step(v, len, nextl))
swap(v + i, v + nextl);
default:
return v[i];
}
}
void heap_sort(int v[], int len){
return (len > 1)?
(heap_sort_step(v, len, 0),
heap_sort(v + 1, len - 1)):
NULL;
}
heap_sort(int v[], int len) takes an array and it's size and builds the min heap for every member in the array using heap_sort_step(), ordering it. Tail calls needed here.
heap_sort_step(int v[], int len, int i) takes an array, it's size and an index for building the heap, with equations as seen in nextl and nextr, 2i+1 and 2i+2, starting with i = 0. 'bfl' is an optimization trick(minor improvements over using ifs) to decide which branches to go to or just return the current value by seeing if there are more items ahead. The switch uses fallthrough and is where the heap is built, 3 and 2 means there are things to the right (0b11, and 0b10) and 1 means there are things to the left (0b01), default behaviour is returning the current number. It used to be written as:
int heap_sort_step(int v[], int len, int i){
int nextl = (((i + 1) * 2) - 1), nextr = nextl + 1;
if(nextl < len)
while(v[i] > heap_sort_step(v, len, nextl))
swap(v + i, v + nextl);
if(nextr < len)
while(v[i] > heap_sort_step(v, len, nextr))
swap(v + i, v + nextr);
return v[i];
}
As for the recursive step, it compares the current number with the returning value from the next function call, and if it is bigger, it swaps, if it is not, there is a cascade return back to the root.
At this point I'm pretty sure it's just a bad implementation and want to know if this is a complexity problem made by the changes or something else. Can it be made to compete with mergesort and quicksort using the same concept? It should be O n(log(n)), right?

Answer 1

Leaving aside the question of the performance impact of recursion, and of how you're relying on tail-call optimization to make the heap_sort() function non-recursive after all, your implementation does not look like heap sort. Heap sort can be described like this:
Arrange the elements to be sorted into a heap (naively, O(n log n); thoughtfully, O(n))
As long as there are at least two elements in the heap, (O(n) iterations)
Swap the head element with the last. (O(1))
Reduce the (logical) heap size by 1. (O(1))
Restore the heap condition. (O(log n) if done right)
Of course, this applies whether you're sorting in increasing order by using a max-heap or in decreasing order by using a min-heap.
As you clarified in comments, your approach is to arrange the array into a min-heap to obtain the least element, then repeat with the n - 1 element tail of the array. That's not heap sort -- it's a variation on selection sort. If well-implemented, it costs O(n2), because each heap-building step must visit at least the n / 2 non-leaf nodes, and therefore costs O(n).

Answer 2

After a few changes it works like a charm, here's the solution:
It's incomplete:
The heap is being formed over and over again for each item, therefore, as pointed by John this is working like a weird selection sort.
Two new functions are added to finish:
void sift(int v[], int len, int i){
int nextl = 2 * i + 1, nextr = nextl + 1;
int next = 0;
if(nextr < len)
if(v[i] > v[nextr]){
if(v[nextr] < v[nextl])
swap(v + i, v + (next = nextr));
else
swap(v + i, v + (next = nextl));
}
if(nextl < len)
if(v[i] > v[nextl])
swap(v + i, v + (next = nextl));
return (next == 0) ? NULL: sift_min(v, len, next);
}
restores the heap. After switching the first and the last it swaps every smaller number down the tree following a single path.
void reverse(int v[], int len){
int i;
for(i = 0; i < len/2; i++)
swap((v + i), (v + (len - (i + 1))));
}
reverses the array after sorting because without knowing about the second step, using a minheap, the sorting occurs in descending order, so it's just there in to make it ascending.
There's an unnecessary recursion in the main block:
void heap_sort(int v[], int len){
return (len > 1)?
(heap_sort_step(v, len, 0),
heap_sort(v + 1, len - 1)):
NULL;
}
Gets replaced with
void heap_sort(int v[], int len){
heapify(v, len, 0);//this is heap_sort_step with a new name
int templen = len
while(templen > 1){
swap(v, v + --templen);
sift(v, templen, 0);
}
reverse(v, len);
}
The final code is:
void swap(int* ref1, int* ref2){
int temp = *ref1;
*ref1 = *ref2;
*ref2 = temp;
}
int heapify(int v[], int len, int i){
int nextl = 2 * i + 1, nextr = nextl + 1;
if(nextr < len)
while(v[i] > heapify(v, len, nextr))
swap(v + i, v + nextr);
if(nextl < len)
while(v[i] > heapify(v, len, nextl))
swap(v + i, v + nextl);
return v[i];
}
void sift(int v[], int len, int i){
int nextl = 2 * i + 1, nextr = nextl + 1;
int next = 0;
if(nextr < len)
if(v[i] > v[nextr]){
if(v[nextr] < v[nextl])
swap(v + i, v + (next = nextr));
else
swap(v + i, v + (next = nextl));
}
if(nextl < len)
if(v[i] > v[nextl])
swap(v + i, v + (next = nextl));
return (next == 0) ? NULL: sift(v, len, next);
}
void reverse(int v[], int len){
int i;
for(i = 0; i < len/2; i++)
swap((v + i), (v + (len - (i + 1))));
}
void heap_sort(int v[], int len){
heapify(v, len, 0);
int templen = len;
while(templen > 1){
swap(v, v + (--templen));
sift(v, templen, 0);
}
reverse(v, len);
}
Lengthy, but it still builds the heap recursively and is fast. Can be made faster using maxheap, and of course, eliminating recursion. A quick test yields an average of less than 0.1 seconds for the same samples that were taking more than a minute.