Дано дерево. Распечатать дерево по уровням

struct bin_tree
{
   int value;
   bin_tree *left, *right;
}
 
void print(bin_tree *tree, const int level = 0)
{      
    if (tree->left) 
        print(tree->left, level + 1);
    for (int i = 0; i < level; i++)
         std::cout << " ";
    std::cout << tree->value << std::endl;
    if (tree->right) 
       print(tree->right, level + 1);
}

#include <iostream>
#include <list>
using namespace std;
 
template<typename T> 
struct Node
{
T key;
Node *left_;
Node *right_;
Node *parent_;
Node *root_;
Node(const T& key_)
:key(key_), left_(nullptr), right_(nullptr)
{root_=this; parent_=this;}
Node(const T& key_, Node *root)
:key(key_), root_(root), left_(nullptr), right_(nullptr), parent_(nullptr)
{}
void insert( Node *x,  Node *z){            // x — корень поддерева, z — вставляемый элемент
    
    while (x != nullptr){
     if (z->key >= x->key)
        if (x->right_ != nullptr)
           x = x->right_;
        else{
           z->parent_ = x;
           x->right_ = z;
           break;
        }
     else if (z->key < x->key)
        if (x->left_ != nullptr)
           x = x->left_;
        else{
           z->parent_ = x;
           x->left_ = z;
           break;
        }
    }
}
void add(Node *x, T key){
 
    if(root_==nullptr){
        root_=new Node(key);
root_->root_=this;
    }
else
{
Node *y=new Node(key, root_);
 
insert( x, y );
}
}
void add(T key){
    if(root_==nullptr){ root_=new Node(key);
        root_->root_=this;
    }
else{
Node *y=new Node(key, root_);
insert( root_, y );
}
}
void inorderTraversal(Node *x){
    if (x != nullptr){
      inorderTraversal(x->left_);
      cout << x->key<<' ';
      inorderTraversal(x->right_);
    }
}
 
void 
get_next_level_nodes_list( 
list<list<Node*>>& list_nodes_by_levels, int level=0    
    ){
list<list<Node*>>::const_iterator it_begin =  list_nodes_by_levels.begin(), it_last =  list_nodes_by_levels.end();
if(it_last == it_begin){
cout<<"The tree is empty"<<endl;
return;
}
it_last--;
list<Node*> list_nodes_next_level;
list<Node*>::const_iterator it=it_last->begin(), it_fin = it_last->end();
cout<<level<<'\t';
for(; it  != it_fin; ++it){
cout<<(*it)->key<<' ';
if((*it)->left_)
list_nodes_next_level.push_back((*it)->left_);
if((*it)->right_)
list_nodes_next_level.push_back((*it)->right_);
}
cout<<endl;
if(!list_nodes_next_level.empty()){
list_nodes_by_levels.push_back(list_nodes_next_level);
get_next_level_nodes_list( list_nodes_by_levels, ++level); 
}
}
 
};
int main(int argc, char* argv[])
{
const int sz=7;
int a[sz]={2,6,1,3,5,7};
Node<int> *node_root=new Node<int>(4);
for(int i=0; i<sz-1; ++i)node_root->add(node_root, a[i] );
cout<<endl;
node_root->inorderTraversal(node_root);
cout<<endl;
cout<<"\nlevels of the tree:\n";
list<Node<int>*> list_nodes_next_level;
list_nodes_next_level.push_back(node_root->root_);
list<list<Node<int>*>> list_nodes_by_levels;
list_nodes_by_levels.push_back(list_nodes_next_level);
node_root->get_next_level_nodes_list(list_nodes_by_levels);
cout<<endl;
system("pause");
return 0;
}

void bfs_print(const vector<vector<bool>>& v, int start) { // матрица смежности и вершина, за которую подвешиваем дерево
    typedef struct Node {
        int id, level;
    };
    map<int,  vector<int>> lvls; // это будем печатать
    queue<Node> q;
    q.push({ start, 1 }); // стартовая вершина, 1 уровень
    vector<bool> used(v.size());
    used[start] = 1;
    while (!q.empty()) {
        auto top = q.front();
        lvls[top.level].push_back(top.id); // закидываем вершину на ее уровень 
        q.pop();
        for (int i = 0; i < v.size(); i++) if (v[top.id][i] && !used[i]) {
            used[i] = 1;
            q.push({ i, top.level + 1 }); // кидаем на уровень ниже (више по номеру, ниже по гравитации)
        }
    }
    for (auto row : lvls) {
        for (auto e : row.second) {
            cout << e << " ";
        }
        cout << endl;
    }
}
 
int main() {
    vector<vector<bool>> v = {
        { false, true, true, false, false, false, false},
        { true, false, false, true, true, false, false },
        { true, false, false, false, false, true, true },
        { false, true, false, false, false, false, false },
        { false, true, false, false, false, false, false },
        { false, false, true, false, false, false, false },
        { false, false, true, false, false, false, false }
 
};
    bfs_print(v, 0);
    return 0;
}