#include <bits/stdc++.h>
using namespace std;

class Task { 
 public:
    void solve() {
        read_input();
        get_result();
        print_output();
    }

 private:
    int n;  // Membru al clasei
    vector<int> v;

    void read_input() {
        ifstream fin("algsort.in");
        fin >> n;
        
        v.resize(n);

        for (int i = 0; i < n; i++) {
            fin >> v[i];
        }

        fin.close();
    }

    // Funcție pentru a reformata un subarbore cu rădăcina în nodul i
    // care este un index în vectorul v
    void heapify(int size, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        // Dacă copilul din stânga este mai mare decât rădăcina
        if (left < size && v[left] > v[largest])
            largest = left;

        // Dacă copilul din dreapta este mai mare decât cel mai mare element de până acum
        if (right < size && v[right] > v[largest])
            largest = right;

        // Dacă cel mai mare element nu este rădăcina
        if (largest != i) {
            swap(v[i], v[largest]);

            // Recursiv reformatează subarborele afectat
            heapify(size, largest);
        }
    }

    // Funcția principală pentru a face heap sort
    void heapSort() {
        // Construiește heap-ul (rearanjează vectorul)
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(n, i);
        }

        // Extrage câte un element din heap
        for (int i = n - 1; i > 0; i--) {
            // Mută rădăcina curentă la sfârșit
            swap(v[0], v[i]);

            // Apelează heapify pe heap-ul redus
            heapify(i, 0);
        }
    }

    void get_result() {
        heapSort();
    }

    void print_output() {
        ofstream fout("algsort.out");
        
        for (int i = 0; i < n; i++) {
            fout << v[i] << " ";
        }
        
        fout.close();
    }
};

int main(void) {
    ios::sync_with_stdio(false);
    Task task;
    task.solve();
    return 0;
}