#include <iostream>
#include <fstream>
using namespace std;

ifstream fin("algsort.in");
ofstream fout("algsort.out");

int parent ( int i )
{
    return i/2;
    //return i>>2;
}

int left ( int i )
{
    return 2*i;
    //return i<<2;
}

int right ( int i )
{
    return 2*i+1;
    //return (i<<2)|1;
}

//o implementare si mai buna era cu macro-uri

void max_heapify ( int A[], int i, int heap_size )
{
    int l, r, largest;
    l = left(i);
    r = right(i);
    if( (l <= heap_size) && (A[l] > A[i]) )
        largest = l;
    else
        largest = i;
    if( (r <= heap_size) && (A[r] > A[largest]) )
        largest = r;
    if( largest != i )
    {
        swap( A[i], A[largest] );
        max_heapify( A, largest, heap_size );
    }
}

void build_max_heap (int A[], int length, int &heap_size)
//length = n
{
    heap_size = length;
    for( int i = length/2; i >= 1; i-- )
        max_heapify(A, i, heap_size);
}

void HeapSort(int A[], int length, int &heap_size)
{
    build_max_heap(A, length, heap_size);
    for(int i = length; i >= 2; i--)
    {
        swap (A[1], A[i]);
        heap_size--;
        max_heapify(A, 1, heap_size);
    }

}

int main()
{
    int A[500001];
    int n, heap_size=0, i;
    //n = A.heap_length
    //initial A.heap_size = 0 pt ca nu are niciun element si treptat va ajunge la n elem, adica == A.heap_length
    fin>>n;
    for(i=1; i<=n; i++)
        fin>>A[i];

    HeapSort(A, n, heap_size);
    for(i=1; i<=n; i++)
        fout<<A[i]<<" ";
}