бинарные деревья

#include <iostream>
#include <conio.h>
using namespace std;
 
struct  bin_tree
{
   int value;
   bin_tree *left, *right;
}*pHead = NULL; // óêàçàòåëü íà âåðøèíó ðàâåí íóëþ
 
// äîáàâëåíèå óçëà äåðåâà
void add_node(bin_tree* tree, int value); 
// ïðîâåðêà íà "ïóñòîòó" äåðåâà, åñëè óêàçàòåëü íà âåðøèíó ðàâåí íóëþ, ñîçäàåò óçåë
void add_bin_tree(int value);
//Ðåêóðñèâíî ðàñïå÷àòûâàåì ýòî äåðåâî îò ìåíüøåãî ýëåìåíòà ê áîëüøåìó
void print(bin_tree* tree, int level);
 
int main()
{
    int mass[] = {10, 12, 19, 92, 1, 9, 20, 10, 91, 61, 14, 88, 9};
    for (int i = 0; i < sizeof(mass) / sizeof(int); i++)
        add_bin_tree(mass[i]);
    print(pHead, 0);
    //cout<< pHead->value<< " "<< pHead->left->value<< " "<< pHead->right->value<< " ";
    getch();
    return 0;
}
 
void add_node(bin_tree* tree, int value) // äîáàâëåíèå êîíêðåòíîãî óçëà äåðåâà
{
    if(value < tree->value)
    { 
        if(tree->left != NULL) // åñëè çíà÷åíèå ìåíüøå, äâèãàåìñÿ ïî "ëåâîé âåòêå"
            add_node(tree->left, value);
        else
        {  
            tree->left = new bin_tree;
            tree->left->value = value;
            tree->left->left = NULL;
            tree->left->right = NULL;
        }
    }
 
    if(value > tree->value) // èíà÷å äâèãàåìñÿ ïî ïðàâîé 
    { 
        if(tree->right != NULL)
            add_node(tree->right, value);
        else
        {
            tree->right = new bin_tree;
            tree->right->value = value;
            tree->right->left=NULL;
            tree->right->right=NULL;
        }
    }
 
    if(value == tree->value)                
        cout<< value<< " is already in tree"<< endl;
}
 
void add_bin_tree(int value)
{
    if(pHead == NULL) // åñëè äåðåâî ïóñòîå - ñîçäàäèì ïåðâûé óçåë
    {
       pHead = new bin_tree;
       pHead->value = value;
       pHead->left = NULL;
       pHead->right = NULL;
    }
    else
        add_node(pHead, value); // åñëè â âåðøèíå óæå ÷òî-òî åñòü - äîáàâëÿåì ñëåâà èëè ñïðàâà 
}
 
void print(bin_tree* tree, int level)
{      
    if (tree->left != NULL) 
        print(tree->left, level + 1);
    for (int i = 0; i < level; i++)
         cout<< " ";
    cout<< tree->value<< endl;
    if (tree->right != NULL) 
       print(tree->right, level + 1);
}

# include <iostream>
 
using namespace std;
 
class Tree          // tree
{
public:
    struct Node     // struct of Tree's elem
    {
        int key;
        Node *left;     
        Node *right;
        void PrintEl(int lvl);
    };
 
private:
    Node *root;     // ук-ль на корень дерева
    void Insert(int k, Node *&root);    // поиск и вставка эл-та
public:
    Tree() {root = 0;}
    Node* GetRoot() {return *&root ;}
    void BuildTree();   // build tree (:
    void TraceLeft(Node *root);
    void PrintTree();
};
 
int main()
{
    Tree tree;
    tree.BuildTree();
    cout << "It's your tree (:" << endl;
    //tree.TraceLeft(tree.GetRoot());
    tree.PrintTree();
    return 0;
}
 
void Tree::BuildTree()
{
    int k;      // it's temporary for key
    cout << "Enter key" << endl;
    while (cin >> k)
        Insert(k, root);
}
 
void Tree::Insert(int k, Node *&root)
{
    if (root == 0)
    {
        root = new Node;
        root->key = k;
        root->left = 0; root->right = 0;
    }
    else if (k < root->key)
            Insert(k, root->left);
        else if (k > root->key)
            Insert(k, root->right);
}
void Tree::TraceLeft(Node *root)
{
    if (root != 0)
    {
        TraceLeft(root->left);
        cout << root->key << " ";
        TraceLeft(root->right);
    }
}
void Tree::PrintTree()
{
    cout << endl;
    if (root)
        root->PrintEl(0);
}
void Tree::Node::PrintEl(int lvl)
{
    for (int i  = 0; i < lvl; i++)
        cout << " ";
    cout << key << endl;
    if (left)
        left->PrintEl(lvl + 1);
    if (right)
        right->PrintEl(lvl + 1);
}

#include <iostream>
#include <clocale>
#include <conio.h>
#include <fstream>
using namespace std;
 
struct node
{
    int Key; 
    int Count; 
    int bal; 
    node *Left, *Right;
};
 
class TREE 
{
  private:
    // h - ôëàã, ñèãíàëèçèðóþùèé îá óâåëè÷åíèè âûñîòû ïîääåðåâà:
    // true - âûñîòà ïîääåðåâà óâåëè÷èëàñü, 
    // false - âûñîòà ïîääåðåâà íå óâåëè÷èëàñü.
    bool h;
    node *Tree;
  public:
    TREE() {Tree = NULL; h = false;}
    void Search (int, node **);
    void Print (node **, int);
    void Traversal (node **);
    node** GetTree() {return &Tree;}
};
 
int main ()
{
    setlocale(LC_ALL, "Russian");
    TREE A;
    int el, n;
    cout<< "Êîëè÷åñòâî âåðøèí â äåðåâå: "; 
    cin>> n;
    cout<< "Èíôîðìàöèîííûå ïîëÿ âåðøèí äåðåâà:\n";
    for (int i=0; i < n; i++)
    { 
        cin>> el;
        A.Search (el, A.GetTree());
    }
    cout<< "\nÀÂË-äåðåâî:\n\n"; 
    A.Print (A.GetTree(), 0);
    A.Traversal (A.GetTree());
    getch();
    return 0;
}
 
void TREE::Search (int x, node **p)
// x - êëþ÷ âåðøèíû, ïîìåùàåìîé â ÀÂË-äåðåâî.
// *p - óêàçàòåëü íà êîðåíü ÀÂË-äåðåâà.
// h - ôëàã, ñèãíàëèçèðóþùèé îá óâåëè÷åíèè âûñîòû ïîääåðåâà:
// true - âûñîòà ïîääåðåâà óâåëè÷èëàñü, 
// false - âûñîòà ïîääåðåâà íå óâåëè÷èëàñü.
// Ïðè ïåðâîì îáðàùåíèè ê ôóíêöèè Search() h=false.
{
    node *p1, *p2;
    h = false;
    if (*p == NULL) // åñëè óêàçàòåëü íà äåðåâî ðàâåí 0
    {  
        *p = new(node);
        h = true; 
        (**p).Key = x; 
        (**p).Count = 1; 
        (**p).Left = (**p).Right = NULL;
        (**p).bal = 0; 
    }
    else 
    if (x <= (**p).Key) 
    {
        Search (x, &((**p).Left)); 
        if (h == true)
            switch ((**p).bal) 
            { 
                case 1 :  (**p).bal = 0; h = false; break; 
                case 0 : (**p).bal = -1; break; 
                case -1: 
                          p1 = (**p).Left; 
                          if ((*p1).bal==-1) 
                          {    
                              (**p).Left = (*p1).Right; 
                              (*p1).Right = *p; 
                              (**p).bal = 0; 
                              *p = p1; 
                          } 
                          else 
                          {
                              p2 = (*p1).Right; 
                              (*p1).Right = (*p2).Left; 
                              (*p2).Left = p1; 
                              (**p).Left = (*p2).Right; 
                              (*p2).Right = *p;
                              if ((*p2).bal == -1) 
                                  (**p).bal = 1; 
                              else 
                                  (**p).bal = 0; 
                              if ((*p2).bal == 1) 
                                  (*p1).bal = -1; 
                              else 
                                  (*p1).bal = 0;
                              *p = p2;
                          } 
                          (**p).bal = 0; 
                          h = false; 
                          break; 
            }
    }
    if (x > (**p).Key) 
    {    
        Search (x, &((**p).Right)); 
        if (h == true)
            switch ((**p).bal) 
            { 
                case -1: (**p).bal = 0; h = false; break; 
                case  0: (**p).bal = 1; break;
                case  1:
                          p1 = (**p).Right; 
                          if ((*p1).bal == 1) 
                          {
                              (**p).Right = (*p1).Left; 
                              (*p1).Left = *p; 
                              (**p).bal = 0; 
                              *p = p1; 
                          } 
                          else
                          {
                               p2 = (*p1).Left; 
                               (*p1).Left = (*p2).Right; 
                               (*p2).Right = p1; 
                               (**p).Right = (*p2).Left; 
                               (*p2).Left = *p; 
                               if ((*p2).bal == 1) 
                                   (**p).bal = -1; 
                               else 
                                   (**p).bal = 0; 
                               if ((*p2).bal == -1) 
                                   (*p1).bal = 1; 
                               else 
                                   (*p1).bal = 0; 
                               *p = p2; 
                          } 
                          (**p).bal = 0; 
                          h = false; 
                          break;
             }
    }
}
 
void TREE::Print (node **w, int lvl)
//Èçîáðàæåíèå äåðåâà w íà ýêðàíå äèñïëåÿ
//         (ðåêóðñèâíûé àëãîðèòì).
//*w - óêàçàòåëü íà êîðåíü äåðåâà.
{
    if  (*w != NULL)
    {
        Print (&((**w).Right), lvl + 1);
        for (int i = 0; i < lvl; i++) 
            cout<< "   ";
        cout<< (**w).Key<< endl;
        Print (&((**w).Left), lvl + 1);
    }
}
 
void TREE::Traversal (node **w)
//*w - óêàçàòåëü íà êîðåíü äåðåâà.
{
    ofstream o("bin.txt");
    if  (*w != NULL)
    {
        Traversal (&((**w).Right));
        o<< (**w).Key<< " ";
        Traversal (&((**w).Left));              
    }
    o.close();
}

void TREE::Traversal (node **w)
//*w - указатель на корень дерева.
{
    ofstream o("bin.txt");
    if  (*w != NULL)
    {
        Traversal (&((**w).Right));
        o<< (**w).Key<< " ";
        Traversal (&((**w).Left));
    }
    o.close();
}