Работа с деревьями (Найти все поддеревья, листья которых находятся в заданном диапазоне высот от корня поддерева)

/////////////////////////////////////////////////////////////////////////////////////////
//Дано N-дерево. Найти все поддеревья, листья которых находятся в заданном диапазоне уровней от корня поддерева.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <functional>
#include <iostream>
#include <set>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
class   T_node;
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<T_node*>    T_children_pointers;
typedef std::set<int>           T_node_heights_set;
typedef std::complex<int>       T_levels_segment;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_node
{
    //-----------------------------------------------------------------------------------
    int                     node_ID_;
 
    T_node_heights_set      node_heights_set_;
    T_children_pointers     children_pointers_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_node(int  node_ID)
        :
        node_ID_(node_ID)
    {}
    //-----------------------------------------------------------------------------------
    bool  to_node_with_ID_add_child_with_ID
        (
            int     node_ID,
            int     child_ID
        )
    {
        bool    bool_res    =   false;
        if(node_ID_ == node_ID)
        {
            children_pointers_.push_back
                (
                    new     T_node(child_ID)
                );
 
            bool_res    =   true;
        }
        else
        {
            for (
                    T_children_pointers::iterator     child_pointer_it  =   children_pointers_.begin    ();
                    child_pointer_it                                    !=  children_pointers_.end      ();
                    ++child_pointer_it
                )
            {
                bool_res    =   (*child_pointer_it)->to_node_with_ID_add_child_with_ID
                                    (
                                        node_ID,
                                        child_ID
                                    );
 
                if( bool_res )
                {
                    break;
                }
            }
        }//else
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    void  calc_min_and_max_leaf_levels_and_print_if_they_belongs_to_segment
        (
            int  min_allowable_max_leaf_level,
            int  max_allowable_max_leaf_level
        )
    {
        if  (
                !children_pointers_.empty()
            )
        {
            for (
                    T_children_pointers::const_iterator     child_pointer_it    =   children_pointers_.begin    ();
                    child_pointer_it                                            !=  children_pointers_.end      ();
                    ++child_pointer_it
                )
            {
                (*child_pointer_it)->calc_min_and_max_leaf_levels_and_print_if_they_belongs_to_segment
                    (
                        min_allowable_max_leaf_level,
                        max_allowable_max_leaf_level
                    );
 
                node_heights_set_.insert
                    (
                        (*child_pointer_it)->min_leaf_level() + 1
                    );
 
                node_heights_set_.insert
                    (
                        (*child_pointer_it)->max_leaf_level() + 1
                    );
            }//for
        }//if
 
        if  (
                    min_allowable_max_leaf_level    <=  min_leaf_level()
                &&  max_leaf_level()                <=  max_allowable_max_leaf_level
            )
        {
            std::cout   <<  "node_ID = "
                        <<  node_ID_
                        <<  '\t'
                        <<  T_levels_segment
                                (
                                    min_leaf_level(),
                                    max_leaf_level()
                                )
 
                        <<  std::endl;
        }//if
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    int  min_leaf_level()
    {
        return  node_heights_set_.empty()
                    ?   0
                    :   *node_heights_set_.begin();
    }
    //-----------------------------------------------------------------------------------
    int  max_leaf_level()
    {
        return  node_heights_set_.empty()
                    ?   0
                    :   *node_heights_set_.rbegin();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    T_node*     tree    =   new     T_node(0);
    tree->to_node_with_ID_add_child_with_ID(0, 1);
    tree->to_node_with_ID_add_child_with_ID(0, 2);
    tree->to_node_with_ID_add_child_with_ID(0, 3);
 
    tree->to_node_with_ID_add_child_with_ID(1, 5);
    tree->to_node_with_ID_add_child_with_ID(1, 6);
 
    tree->to_node_with_ID_add_child_with_ID(2, 4);
 
    tree->to_node_with_ID_add_child_with_ID(3, 11);
 
    tree->to_node_with_ID_add_child_with_ID(4, 8);
    tree->to_node_with_ID_add_child_with_ID(4, 9);
 
    tree->to_node_with_ID_add_child_with_ID(6, 7);
 
    tree->to_node_with_ID_add_child_with_ID(9, 10);
 
    tree->to_node_with_ID_add_child_with_ID(11, 12);
 
    tree->to_node_with_ID_add_child_with_ID(12, 13);
    tree->to_node_with_ID_add_child_with_ID(12, 14);
 
    tree->to_node_with_ID_add_child_with_ID(14, 15);
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  "Введите желаемый диапазон уровней узлов поддерева от корня поддерева:"
                    <<  std::endl
                    <<  "min = ";
 
        int     min     =   0;
        std::cin    >>  min;
 
        std::cout   <<  "max = ";
        int     max     =   0;
        std::cin    >>  max;
 
        std::cout   <<  "Корни поддеревьев, листья которых находятся в этом диапазоне уровней от корня поддерева:"
                    <<  std::endl;
 
        tree->calc_min_and_max_leaf_levels_and_print_if_they_belongs_to_segment
            (
                min,
                max
            );
    }
}