Дерево дерево, странное дерево

/////////////////////////////////////////////////////////////////////////////////////////
//Вершина дерева содержит N целых значений и два указателя на потомков. Запись значений 
//производится таким образом, что меньшие значения оказываются ближе к корню дерева 
//(то есть все значения в поддеревьях больше самого большого значения у предка). 
//Разработать функции включения и поиска данных в таком дереве. Если новое значение 
//«проходит» через вершину, в которой находится большее, то оно замещает большее значение, 
//а для последнего - алгоритм продолжается. Функция включения выбирает потомка с максимальным 
//значением в поддереве.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_strange_node
{
    int                 val_;
    T_strange_node*     min_;
    T_strange_node*     max_;
    //-----------------------------------------------------------------------------------
    T_strange_node
        (
            int                 val     =   0,
            T_strange_node*     min     =   0
        )
        :
        val_    ( val ),
        min_    ( min ),
        max_    ()
    {}
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
bool  successfully_find_val_in_strange_node
    (
        int                 val,
        T_strange_node*     node_p
    )
{
    if  (
                node_p  ==  0
            ||  val     <   node_p->val_
        )
    {
        return  false;
    }
    else
    {
        if( val == node_p->val_ )
        {
            return  true;
        }
        else
        {
            return      successfully_find_val_in_strange_node
                            (
                                val,
                                node_p->min_
                            )
 
                    ||  successfully_find_val_in_strange_node
                            (
                                val,
                                node_p->max_
                            );
        }//else
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
void  insert_val_in_strange_tree
    (
        int                     val,
        T_strange_node*     &   node_p
    )
{
    if( node_p == 0 )
    {
        node_p  =   new     T_strange_node( val );
    }
    else
    {
        if( val < node_p->val_ )
        {
            //Записываем в значение, а дерево переносим в потомка.
            node_p  =   new     T_strange_node
                                    (
                                        val,
                                        node_p
                                    );
        }
        else
        {
            //Записываем в потомки.
            if  (
                    node_p->min_    ==  0
                )
            {
                node_p->min_    =   new     T_strange_node( val );
            }
            else if (
                        node_p->max_    ==  0
                    )
            {
                node_p->max_    =   new     T_strange_node( val );
                if  ( node_p->min_->val_ > node_p->max_->val_ )
                {
                    std::swap
                        (
                            node_p->min_,
                            node_p->max_
                        );
                }//if
            }//else
            else
            {
                if( val >= node_p->max_->val_ )
                {
                    insert_val_in_strange_tree
                        (
                            val,
                            node_p->max_
                        );
                }
                else
                {
                    insert_val_in_strange_tree
                        (
                            val,
                            node_p->min_
                        );
                }//else
            }//else
        }//else
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
void print_tree
    (
        T_strange_node  *   node_p,
        int                 level   =   0
    )
{
    if( node_p )
    {
        print_tree
            (
                node_p->min_,
                level + 1
            );
 
        for( int  i = 0; i < level; ++i )
        {
            std::cout   <<  '\t';
        }//for
 
        std::cout   <<  node_p->val_
                    <<  std::endl;
 
        print_tree
            (
                node_p->max_,
                level + 1
            );
    }//if
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
 
    T_strange_node*     tree    =   0;
 
    for(;;)
    {
        int     val     =   0;
        std::cout   <<  "Введите натуральное значение для добавления в дерево: ";
        std::cin    >>  val;
 
        if( val <= 0 )
        {
            break;
        }
 
        insert_val_in_strange_tree
            (
                val,
                tree
            );
 
        std::cout   <<  std::endl;
        print_tree( tree );
 
        int     val_for_find    =   0;
 
        do
        {
            std::cout   <<  std::endl
                        <<  "Введите натуральное значение для поиска в дереве (0 - завершение поиска): ";
 
            std::cin    >>  val_for_find;
 
            std::cout   <<  "значение "
                        <<  val_for_find
                        <<  " в дереве "
                        <<  (
                                successfully_find_val_in_strange_node
                                    (
                                        val_for_find,
                                        tree
                                    )
                                    ?   "присутствует."
                                    :   "отсутствует."
                            )
 
                        <<  std::endl;
        }
        while( val_for_find > 0 );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}