// Heap sort
#include <fstream>

using namespace std;

int parent(int i);
int leftSon(int i);
int rightSon(int i);
void siftUpMin(int a[], int index);
int extractMin(int a[], int &length);
void siftDownMin(int a[], int i, int &length);

int main()
{
    ifstream f("algsort.in");
    int N;
    f >> N;
    int a[N], length = -1;

    int x, i;
    for (i = 0; i < N; i++)
    {
        f >> x;
        a[++length] = x;
        siftUpMin(a, length);
    }
    f.close();

    ofstream g("algsort.out");
    for (i = 0; i < N; i++)
        g << extractMin(a, length) << " ";
    g.close();

    return 0;
}

int parent(int i)
{
    return (i - 1) / 2;
}

int leftSon(int i)
{
    return i * 2 + 1;
}

int rightSon(int i)
{
    return i * 2 + 2;
}

void siftUpMin(int a[], int i)
{
    if (i)
    {
        if (a[parent(i)] > a[i])
        {
            int aux = a[parent(i)];
            a[parent(i)] = a[i];
            a[i] = aux;
            siftUpMin(a, parent(i));
        }
    }
}

int extractMin(int a[], int &length)
{
    int min = a[0];
    a[0] = a[length--];
    siftDownMin(a, 0, length);
    return min;
}

void siftDownMin(int a[], int i, int &length)
{
    if (leftSon(i) <= length && rightSon(i) <= length)
    {
        int minI = (a[leftSon(i)] < a[rightSon(i)]) ? leftSon(i) : rightSon(i);
        if (a[i] > a[minI])
        {
            swap(a[i], a[minI]);
            siftDownMin(a, minI, length);
        }
    }
    else if (leftSon(i) <= length)
    {
        if (a[i] > a[leftSon(i)])
        {
            swap(a[i], a[leftSon(i)]);
            siftDownMin(a, leftSon(i), length);
        }
    }
    else if (rightSon(i) <= length)
    {
        if (a[i] > a[rightSon(i)])
        {
           swap(a[i], a[rightSon(i)]);
           siftDownMin(a, rightSon(i), length);
        }
    }
}