Бинарные деревья с обратной связью

#include <iostream>
#include <fstream>
using namespace std;
struct Node
{
int info;
Node *left;
Node *right;
};
Node * addNode(int key)
{
Node * tmp;
tmp = new Node;
tmp->info = key;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
bool add(Node * first, int key)
{
Node * tmp = first;
if(tmp->info == key) return false;
if(tmp->info > key)
{
if(tmp->left) return add(tmp->left,key);
else
{
tmp->left = addNode(key);
return true;
}
}
else
{
if(tmp->right) return add(tmp->right,key);
else
{
tmp->right = addNode(key);
return true;
}
}
}
bool add_not_recursiv(Node *first,int key)
{
Node * tmp = first;
 
while(tmp!= NULL)
{
if(tmp->info == key) return false;
if(tmp->info > key)
{
if(tmp->left)tmp = tmp->left;
else break;
}
else
{
if(tmp->right)tmp = tmp->right;
else break;
}
}
if(tmp->info > key)tmp->left = addNode(key);
else tmp->right = addNode(key);
return true;
}
 
int min(Node *first)
{
Node *tmp = first;
while(tmp->left) tmp = tmp->left;
return tmp->info;
}
 
void print_Tree(Node * p,int level)
{
if(p)
{
print_Tree(p->left,level + 1);
for(int i = 0;i< level;i++) cout«" ";
cout « p->info « endl;
print_Tree(p->right,level + 1);
}
}
void print(Node *p)
{
if(p)
{
print(p->left);
 
cout « p->info «" ";
 
print(p->right);
}
 
}
int main()
{
Node *first;
ifstream f;
f.open("input.txt",ios::in);
int key;
f»key;
first = addNode(key);
/*while(!f.eof())
{
f » key;
if(!add(first,key)) cout«"Repeat "«key«endl;
}*/
 
while(!f.eof())
{
f » key;
if(!add_not_recursiv(first,key)) cout«"Repeat "«key«endl;
}
print_Tree(first,0);
cout«" Min = "«min(first)«endl;
cout «"Sort"«endl;
print(first);
return 0;
}

class Node {
protected:
    int m_Value;
    Node *m_pParent;
    Node *m_pLeft;
    Node *m_pRight;
public:
    Node (int value) : m_Value (value), m_pParent (NULL), m_pLeft (NULL), m_pRight (NULL){};
    ~Node () { delete m_pLeft; delete m_pRight; }
 
    void setChildren (Node *pLeft, Node *pRight){ m_pLeft = pLeft;
            m_pRight = pRight;
            m_pLeft->m_pParent = this;
            m_pRight->m_pParent = this;
    }
    const Node* getParent () { return m_pParent; };
    const Node* getLeft () { return m_pLeft; };
    const Node* getRight () { return m_pRight; };
    const Node* getSibling () {
        if ( m_pParent != NULL){
            if (m_pParent->m_pLeft == this){
                return m_pParent->m_pRight;
            } else {
                return m_pParent->m_pLeft;
            }
        } else {
            return NULL;
        }
    }
    int getValue () { return m_Value; }
};
 
void populate (Node *pRoot){
    // level 1 (4 nodes)
    Node *pNodeL10 = new Node (5);
    Node *pNodeR10 = new Node (7);
    Node *pNodeL11 = new Node (2);
    Node *pNodeR11 = new Node (76);
 
    // level 0 (two nodes)
    Node *pNodeL00 = new Node (3);
    Node *pNodeR00 = new Node (13);
 
    pRoot->setChildren (pNodeL00, pNodeR00);
    pNodeL00->setChildren (pNodeL10, pNodeR10);
    pNodeR00->setChildren (pNodeL11, pNodeR11);
}
 
void test(){
    Node root (111);
    populate (&root);
    const Node *pTestNode = root.getLeft();
    if (pTestNode != NULL){
        // выведи родителя и детей этого узла можешь получить "брата" с помощью getSibling();
        ...
        //ну, и т.д.
    }
}