Algorytmy sortowania

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<conio.h>

void heapify(int* , int , int );
void buildHeap(int* ,int );
void heapSort(int* ,int );

void merge(int*,int,int,int);
void mergeSort(int*,int,int);

void quickSort(int* , int , int );

int main()
{
    char esc;
    int k,n;
    int* A;
    clrscr();
    do
    {
        printf("Podaj liczbe elementow tablicy\n");
        scanf("%d",&n);
        printf("\n");
        srand(time(NULL));
        A=(int*)malloc(n*sizeof(int));
        for(k=0; k<n; k++)
            A[k]=rand()%100;
        printf("Tablica przed sortowaniem\n\n");
        for(k=0; k<n; k++)
            printf("%d ",A[k]);
        printf("\n\n");
        heapSort(A,n);
        //mergeSort(A,0,n-1);
        //quickSort(A,0,n-1);
        printf("Tablica po sortowaniu\n\n");
        for(k=0; k<n; k++)
            printf("%d ",A[k]);
        printf("\n\n");
        free(A);
        esc=getch();
    }
    while(esc!=27);
    return 0;
}

void heapify(int* A, int l, int p)
{
    int i,j;
    int x;
    int isHeap;
    x=A[l];
    i=l;
    j=(2*i)+1;
    isHeap=0;
    while(j<=p && !isHeap)
    {
        if(j<p && A[j]<A[j+1])
            j++;
        if(x<A[j])
        {
            A[i]=A[j];
            i=j;
            j=(2*i)+1;
        }
        else
            isHeap=1;
    }
    A[i]=x;
}

void buildHeap(int* A,int n)
{
    int i;
    for(i=(n-2)/2; i>=0; i--)
        heapify(A,i,n-1);
}

void heapSort(int* A,int n)
{
    int i;
    int x;
    buildHeap(A,n);
    for(i=n-1; i>=1; i--)
    {
        x=A[0];
        A[0]=A[i];
        A[i]=x;

        heapify(A,0,i-1);
    }
}

void merge(int* A,int p,int q,int r)
{
    int n1,n2,i,j,k;
    int* B;
    n1=q-p+1;
    n2=r-q;
    B=(int*)malloc((n1+n2)*sizeof(int));
    for(k=p; k<=r; k++)
        B[k-p]=A[k];
    i=0;
    j=n1;
    k=p;
    while(i<n1 && j<n1+n2)
    {
        if(B[i]<=B[j])
        {
            A[k]=B[i];
            i++;
        }
        else
        {
            A[k]=B[j];
            j++;
        }
        k++;
    }
    while(i<n1)
    {
        A[k]=B[i];
        i++;
        k++;
    }
    while(j<n1+n2)
    {
        A[k]=B[j];
        j++;
        k++;
    }
    free(B);
}

void mergeSort(int* A,int p,int r)
{
    int q;
    if(p<r)
    {
        q=(p+r)/2;
        mergeSort(A,p,q);
        mergeSort(A,q+1,r);
        merge(A,p,q,r);
    }
}

void quickSort(int *A, int l, int p)
{
    int v;
    int i,j;
    int x;
    v=A[(l+p)/2];
    i=l;
    j=p;
    do
    {
        while(A[i]<v) i++;
        while (A[j]>v) j--;
        if(i<=j)
        {
            x=A[i];
            A[i]=A[j];
            A[j]=x;
            i++;
            j--;
        }
    }
    while(i<=j);
    if(j>l) quickSort(A,l, j);
    if(i<p) quickSort(A, i, p);
}
 

Dlaczego po usunięciu fragmentu kodu ze zmienną logiczną isHeap funkcja przywracająca kopiec nie zatrzymuje się w rozsądnym czasie
Ile pamięci zajmuje rekurencja w tej wersji quickSort i jak się jej pozbyć ?
Co do sortowania przez scalanie to jak wyglądałaby wersja działająca w miejscu przy zachowaniu obecnej złożoności czasowej

Wynalazłem u siebie taką funkcję heapify:

 int left(int a){
    return 2*a;   
      
}
int right(int a){
    return 2*a + 1;
    
}
void zamien(int A[], int i, int j){
    int pom = A[i];
    A[i] = A[j];
    A[j] = pom;
}
void heapify(int A[], int i, int heapsize ){
		int l = left(i);
		int r = right(i);
		int myLargest;
	
			if((l <= heapsize) && (A[l] > A[i]))
				myLargest = l;
					else myLargest = i;
			
			if((r <= heapsize) && (A[r] > A[myLargest]))
				myLargest = r;		
			if(myLargest !=i){
				zamien(A, i, myLargest);
				heapify(A, myLargest, heapsize);
			}
}

Wydaje mi się, że działa.
Iterative quicksort: http://www.geeksforgeeks.org/iterative-quick-sort/
Co do różnic między merge sort, quicksort, to od dawna już wiadomo, że quicksort jest najlepszy:)