Синников С++ / 2 курс / С++ / 6,3 / main

/*9. Описать рекурсивную функцию или процедуру, которая определяет максимальную глубину непустого дерева Т,
 т.е. Число ветвей в самом длинном из путей от корня дерева до листьев.*/
#include <iostream>
#include <stdlib.h>
#include <locale.h>

using namespace std;

struct P_Node
{
    int key;
    P_Node *left;
    P_Node *right;
};
class Tree
{
public:
    P_Node *tree;
    Tree()
    {
        tree=NULL;
    }
    void PrintKey(P_Node *t)
    {
        cout << t->key <<" ";
    }
    void preorder(P_Node *t) //обход в прямом порядке
    {
        if (t!=0)
        {
            PrintKey(t); // обработать корневой узел
            preorder(t->left);// обойти левое поддерево в нисходящем порядке
            preorder(t->right);//обойти правое поддерево в нисходящем пор-ке
        }
    }
    // обход снизу вверх Л-П-К обратный порядок
    void postorder(P_Node *t)
    {
        if (t!=0)
        {
            postorder(t->left);// обойти левое поддерево в восходящем порядке
            postorder(t->right);//обойти правое поддерево в восходящем пор-ке
            PrintKey(t); // обработать корневой узел
        }
    }

    // обход слева направо(смешанный) Л-К-П симметричный порядок
    void inorder(P_Node *t)
        {
        if (t!=0)
        {
            inorder(t->left);//обойти левое поддерево в смешанном порядке
            PrintKey(t); // обработать корневой узел
            inorder(t->right);//обойти правое поддерево в смешанном порядке
        }
    }
    //вставка элемента
    void InsertInTree(P_Node **t, int k)
    {
        if (*t==0)// если найдено место для нового узла
        {
            *t=new P_Node;// распределяем память
            (*t)->left=0;// устанавливаем пустые ссылки для левого и
            (*t)->right=0;// правого поддеревьев
            (*t)->key=k;// заполняем ключевое поле
        }
        /* иначе определяем, в каком поддереве узла t
        должен располагаться элемент с таким ключом */
        else
        {
            if (k<=(*t)->key)// если новый ключ меньше или равен текущему
            {
                InsertInTree(&((*t)->left), k);// вставим в левое поддерево
            }
            else
            {
                InsertInTree(&((*t)->right), k);// а иначе – в правое
            }
        }
    }

    P_Node *Del(P_Node **w,P_Node **t)// поиск самого правого элемента
    {
        if ((*w)->right!=0)
        {
            return Del(&((*w)->right),&(*t));
        }
        else
        {
            (*t)->key=(*w)->key;
            (*w)=(*w)->left;
            return *w;
        }
    }
    //функция удаления элемента
    void DeleteFromTree(P_Node **t, int k)
    {
        P_Node *q, *w;
        if (*t!=0)
        {
            if (k<(*t)->key)
            {
                DeleteFromTree(&((*t)->left),k);
            }
            else
            {
                if (k>(*t)->key)
                {
                    DeleteFromTree(&((*t)->right),k);
                }
                else
                {
                    q=*t;
                    if ((*t)->right==0)// правого поддерева нет
                    {
                        *t=(*t)->left;
                    }
                    else
                    {
                        if ((*t)->left==0)// левого поддерева нет
                        {
                            (*t)=(*t)->right;
                        }
                        else// находим самый правый элемент в левом поддереве
                        {
                            q= Del(&((*t)->left), &(*t));
                            free(q);
                        }
                    }
                }
            }
        }
    }
    //метод который ищет максимальную глубину дерева ()
    int getMaxDepth(P_Node *t, int depth)
    {
        if (t == NULL) return depth;
        return max(getMaxDepth(t->left, depth + 1), getMaxDepth(t->right, depth + 1));
    }
};

int main()
{
    setlocale(LC_ALL,"RUS");
    Tree tree;
    bool exit = false; //отвечает за выход из программы
    while(!exit)
    {
        int input;
        cout<<"Выберете действие над деревом:"<<endl;
        cout<<"0 - Закончить выполнение программы "<<endl;
        cout<<"1 - Добавить элемент "<<endl;
        cout<<"2 - Удалить элемент "<<endl;
        cout<<"3 - Узнать максимальную глубину дерева "<<endl;
        cout<<"4 - Вывести дерево на консоль "<<endl;
        cout<<"----------------------------------------------------------------------"<<endl;
        cin>>input;
        switch(input)
        {
            case 0:
            {
                exit = true;
                break;
            }
            case 1:
            {
                cout<<"Введите элемент для вставки в дерево: ";
                int k; cin>>k;
                tree.InsertInTree(&tree.tree,k);
                cout<<"----------------------------------------------------------------------"<<endl;
                break;
            }
            case 2:
            {
                cout<<"Введите элемент для удаления из дерева: ";
                int k; cin>>k;
                tree.DeleteFromTree(&tree.tree,k);
                cout<<"----------------------------------------------------------------------"<<endl;
                break;
            }
            case 3:
            {
                cout<<"Максимальная глубина дерева = "<<tree.getMaxDepth(tree.tree,0)<<endl;
                cout<<"----------------------------------------------------------------------"<<endl;
                break;
            }
            case 4:
            {
                cout<<"Введите способ вывода дерева: 1-прямой 2-обратный 3-симметричный :";
                int k; cin>>k;
                switch(k)
                {
                    case 1:
                    {
                        tree.preorder(tree.tree);
                        break;
                    }
                    case 2:
                    {
                        tree.postorder(tree.tree);
                        break;
                    }
                    case 3:
                    {
                        tree.inorder(tree.tree);
                        break;
                    }
                }
                cout<<endl;
                cout<<"----------------------------------------------------------------------"<<endl;
            }
        }
    }
    return 0;
}