пирамидная сортировка

#include <fstream>
#include <string>
#include <iostream>
#include <climits>
using namespace std;
int Left(int x);
int Right (int x);
void MaxHeapify(int *A, int x, int *heap_size);
void MaxHeapify2(int *A, int x, int *heap_size);
void BuildMaxHeap(int *A,int *heap_size,int mode);
void swap(int &a, int &b);
void HeapSort(int *A, int heap_size,int mode);
int MaxElem(int *H,int hl);
int MinElem(int *H, int hh);
 
int main(int argc, char *argv[])
{
    string s;
    int *m1=new int, *m2=new int;
    int *n= new int;
    int max;
    int *heap_size = new int;
    cin>>s;
    ifstream input(s/*argv[1]*/);
    input>>(*n);
    int *Hlow=new int [*n];
    int *Hhigh=new int [*n];
    int *A=new int [*n];
    int hh=0, hl=0;
    ofstream output;
              output.open("out.txt");
 
        for(int i=0;i<*n;i++)
        {
            input >> A[i];
        }
        
        for (int i=0;i<*n;i++)
        {
            int k=i+1;
 
        /*  for (int l=0;l<=i;l++)
                cout << A[l]<< " ";*/
            if (i==0)
                {
                Hlow[i]=A[i];
                hl++;
                output << Hlow[i]<<endl;
                max=MaxElem(Hlow,hl);
                continue;
                }
            max=MaxElem(Hlow,hl);
                if (A[i]<max)
                {
                    Hlow[hl]=A[i];
                    hl++;
                /*  cout << "Hlow before:"<<endl;
                        for (int j=0;j<hl;j++)
                            cout << Hlow[j]<<" ";
                        cout << endl;*/
                    HeapSort(Hlow,hl-1,0);
                    /*cout << "Hlow after:"<<endl;
                    for (int j=0;j<hl;j++)
                        cout << Hlow[j]<< " ";
                    cout << endl;*/
                }
                else
                {
                    Hhigh[hh]=A[i];
                    hh++;
                /*  cout << "High before:"<<endl;
                        for (int j=0;j<hh;j++)
                            cout << Hhigh[j]<<" ";
                        cout << endl;*/
                    HeapSort(Hhigh,hh-1,1);
                    /*cout << "Hhigh after:"<<endl;
                    for (int j=0;j<hh;j++)
                            cout << Hhigh[j]<<" ";
                        cout << endl;*/
                }
                if (hh-hl>=2)
                    {
                    int min=MinElem(Hhigh,hh);
                    hh--;
                    Hlow[hl]=min;
                    hl++;
                    HeapSort(Hlow,hl-1,0);
                    }
                if (hl-hh>=2)
                    {
                    max=MaxElem(Hlow,hl);
                    hl--;
                    Hhigh[hh]=max;
                    hh++;
                    HeapSort(Hhigh,hh-1,1);
 
                    }
                if (hh==hl)
                    output << Hlow[hl-1] << " "<<Hhigh[hh-1];
                if (hl-hh==1)
                    output << Hlow[hl-1];
                if (hh-hl==1)
                    output << Hhigh[hh-1];
                output << endl;
 
            }
 
system("pause");
    return 0;
 
        }
 
int Left (int x)
{
return (2*x);
}
int Right(int x)
{
return (2*x+1);
}
void MaxHeapify(int *A, int x,int *heap_size)
{
int largest;
int l=Left(x);
int r=Right(x);
    if ((l<=*heap_size) && (A[l]>A[x]))
    {
        largest=l;
    }
    else
    {
        largest=x;
    }
    if ((r<=*heap_size) && (A[r]>A[largest]))
    {largest=r;}
    if (largest!=x)
    {
        swap(A[x],A[largest]);
        MaxHeapify(A,largest,heap_size);
    }
}
void MaxHeapify2(int *A, int x,int *heap_size)
{
int largest;
int l=Left(x);
int r=Right(x);
    if ((l<=*heap_size) && (A[l]<A[x]))
    {
        largest=l;
    }
    else
    {
        largest=x;
    }
    if ((r<=*heap_size) && (A[r]<A[largest]))
    {largest=r;}
    if (largest!=x)
    {
        swap(A[x],A[largest]);
        MaxHeapify2(A,largest,heap_size);
    }
}
void BuildMaxHeap(int* A, int *heap_size,int mode)
{
    if (mode==0)
    {
    for (int i=(*heap_size)/2;i>=0;i--)
    {
 
        MaxHeapify(A,i,heap_size);
        
    }
    }
    if (mode==1)
    {
    for (int i=(*heap_size)/2;i>=0;i--)
    {
 
        MaxHeapify2(A,i,heap_size);
        
    }
    }
}
void swap(int &a, int &b)
    {
        int temp;
        temp=a;
        a=b;
        b=temp;
    }
void HeapSort(int *A,int heap_size, int mode)
{
    if (mode==0)
    {
    BuildMaxHeap(A, &heap_size,mode);
 
        for (int i=heap_size;i>0;i--)
        {
        /*  cout << A[1] <<" "<< A[i]<<endl;*/
            swap(A[0],A[i]);
        /*  cout << A[1] <<" "<< A[i];*/
            heap_size=heap_size-1;
            MaxHeapify(A,0,&heap_size);
        }
    }
    if (mode==1)
    {
    BuildMaxHeap(A, &heap_size,mode);
 
        for (int i=heap_size;i>0;i--)
        {
        /*  cout << A[1] <<" "<< A[i]<<endl;*/
            swap(A[0],A[i]);
        /*  cout << A[1] <<" "<< A[i];*/
            heap_size=heap_size-1;
            MaxHeapify2(A,0,&heap_size);
        }
    }}
int MaxElem(int *H, int hl)
{
    int result=H[0];
    for (int i=0;i<=hl;i++)
            if (H[i]>result)
                result=H[i];
    return result;
 
 
}
int MinElem(int *H, int hh)
{
    int result=H[0];
    for (int i=0;i<hh;i++)
            if (H[i]<result)
                result=H[i];
    return result;
}