#include<bits/stdc++.h>

using namespace std;

#define ll long long

const int mod = 1e9 + 7;

const int N = 5e5 + 10;

struct Node {
    int value;
    Node *left,*right;
    Node(int val) {
        this -> value = val;
        this -> left = NULL;
        this -> right = NULL;
    }
}*root;

vector<int> allNodes;
vector<int> allNodesMinHeap;


void getAllNodes(Node *curr) {
    if (!curr) return ;
    getAllNodes(curr -> left);
    allNodes.push_back(curr -> value);
    getAllNodes(curr -> right);
}

void getAllNodesMinHeap(Node *curr) {
    queue<Node *> qu;
    qu.push(curr);
    while(!qu.empty()) {
        queue<Node *> quTmp;
        while(!qu.empty()) {
            Node *node = qu.front();
            allNodesMinHeap.push_back(qu.front() -> value);
            qu.pop();
            if (node -> left && node -> right) {
                quTmp.push(node -> left);
                quTmp.push(node -> right);
            }
        }
        qu = quTmp;
    }

    for (auto it : allNodesMinHeap) cout << it << " ";
}
void convert_bst_to_min_heap(Node *curr) {
    getAllNodes(curr);
    queue<Node *> qu;
    int indx = 0;
    Node *min_heap = new Node(allNodes[indx]);
    qu.push(min_heap);
    while(!qu.empty()) {
        queue<Node *> quTmp;
        while(!qu.empty()) {
            Node *node = qu.front();
            qu.pop();
            if (indx + 1 < allNodes.size()) {
                node -> left = new Node(allNodes[++indx]);
                quTmp.push(node -> left);
                node -> right = new Node(allNodes[++indx]);
                quTmp.push(node -> right);

            }
        }
        qu = quTmp;
    }
    getAllNodesMinHeap(min_heap);
}


int main() {

    root = new Node(5);

    root -> left = new Node(3);
    root -> right = new Node(8);
    root -> left -> left = new Node(2);
    root -> left -> right = new Node(4);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node(10);
    convert_bst_to_min_heap(root);

    return 0;
}