예제 #1
0
        /// <summary>
        /// Удаляет узел из дерева
        /// </summary>
        /// <param name="node">Удаляемый узел</param>
        public void Remove(AVLTree node)
        {
            if (node == null)
            {
                return;
            }
            var me = MeForParent(node);

            //Если у узла нет дочерних элементов, его можно смело удалять
            if (node.Left == null && node.Right == null)
            {
                if (node.Parent == null)
                {
                    Data = null;
                    return;
                }
                if (me == BinSide.Left)
                {
                    node.Parent.Left = null;
                }
                else
                {
                    node.Parent.Right = null;
                }

                var     mefx = MeForParent(node.Parent);
                AVLTree t    = Balance(node.Parent);

                if (t.Parent != null)
                {
                    if (mefx == BinSide.Left)
                    {
                        t.Parent.Left = t;
                    }
                    else
                    {
                        t.Parent.Right = t;
                    }
                }
                return;
            }
            //Если нет левого дочернего, то правый дочерний становится на место удаляемого
            if (node.Left == null)
            {
                if (me == BinSide.Left)
                {
                    node.Parent.Left = node.Right;
                }
                else
                {
                    node.Parent.Right = node.Right;
                }
                node.Right.Parent = node.Parent;
                return;
            }
            //Если нет правого дочернего, то левый дочерний становится на место удаляемого
            if (node.Right == null)
            {
                if (me == BinSide.Left)
                {
                    node.Parent.Left = node.Left;
                }
                else
                {
                    node.Parent.Right = node.Left;
                }
                node.Left.Parent = node.Parent;
                return;
            }

            //Если присутствуют оба дочерних узла
            AVLTree temp = FindMax(node.Left);

            node.Data = temp.Data;
            AVLTree b = temp.Parent;

            Remove(temp);
        }
        /// <summary>
        /// Обработчик нажатия на кнопку Выполнить
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Calculate_Click(object sender, EventArgs e)
        {
            int    k      = Operations.SelectedIndex;
            int    r      = Realisations.SelectedIndex;
            string result = "";

            // Если дерево пустое, то разрешается только вставка
            if ((AVLtree.Data == null && k != 0 && r == 0) || (BinaryTree.Data == null && k != 0 && r == 1) || (BinaryTreeA.tree[1] == null && k != 0 && r == 2))
            {
                MessageBox.Show("Дерево пусто!", "Ошибка");
                return;
            }

            switch (k)
            {
            case 0:     // Вставка
                if (!CheckInput())
                {
                    return;
                }                                 // Проверка вводимых данных
                switch (r)
                {
                case 0:
                    timeAVL.TimeStart();         // запуск времени
                    AVLtree = AVLtree.Insert(Convert.ToInt32(DataInput.Text));
                    timeAVL.InsertTimeStop();    // остановка времени
                    break;

                case 1:
                    timeBP.TimeStart();         // запуск времени
                    BinaryTree.Insert(Convert.ToInt32(DataInput.Text));
                    timeBP.InsertTimeStop();    // остановка времени
                    break;

                case 2:
                    timeBA.TimeStart();         // запуск времени
                    BinaryTreeA.Insert(Convert.ToInt32(DataInput.Text));
                    timeBA.InsertTimeStop();    // остановка времени
                    break;
                }
                break;

            case 1:
                if (!CheckInput())
                {
                    return;
                }
                switch (r)     // Удаление
                {
                case 0:
                    timeAVL.TimeStart();        // запуск времени
                    AVLtree = AVLtree.Remove(Convert.ToInt32(DataInput.Text));
                    timeAVL.RemoveTimeStop();   // остановка времени
                    break;

                case 1:
                    timeBP.TimeStart();        // запуск времени
                    BinaryTree.Remove(Convert.ToInt32(DataInput.Text));
                    timeBP.RemoveTimeStop();   // остановка времени
                    break;

                case 2:
                    timeBA.TimeStart();
                    BinaryTreeA.RemoveNodeData(Convert.ToInt32(DataInput.Text));
                    timeBA.RemoveTimeStop();         // остановка времени
                    break;
                }
                break;

            case 2:
                int height = 0;
                switch (r)     // Высота дерева
                {
                case 0:
                    height = AVLtree.Height(AVLtree);
                    break;

                case 1:
                    height = BinaryTree.Height(BinaryTree);
                    break;

                case 2:
                    height = BinaryTreeA.Height(1);
                    break;
                }
                result = "Высота дерева = " + height;
                break;

            case 3:
                switch (r)     // Удаление дерева
                {
                case 0:
                    AVLtree = new AVLTree();
                    break;

                case 1:
                    BinaryTree = new BinaryTreeP();
                    break;

                case 2:
                    BinaryTreeA = new BinaryTreeArray();
                    break;
                }
                Mgraph        = new Graph("Tree");
                gViewer.Graph = Mgraph;
                break;

            case 4:
                int width = 0;
                switch (r)     // Максимальная ширина
                {
                case 0:
                    width = AVLtree.MaxWidth(AVLtree);
                    break;

                case 1:
                    width = BinaryTree.MaxWidth(BinaryTree);
                    break;

                case 2:
                    width = BinaryTreeA.MaxWidth(1);
                    break;
                }
                result = "Максимальная ширина дерева = " + width;
                break;

            case 5:
                int nodes = 0;
                switch (r)     // Количество узлов
                {
                case 0:
                    nodes = AVLtree.NumNodes(AVLtree);
                    break;

                case 1:
                    nodes = BinaryTree.NumNodes(BinaryTree);
                    break;

                case 2:
                    nodes = BinaryTreeA.CountElements();
                    break;
                }
                result = "Количество узлов в дереве = " + nodes;
                break;

            case 6:
                if (!CheckInput())
                {
                    return;
                }
                Mgraph = new Graph("Tree");
                switch (r)     // Поиск узла
                {
                case 0:
                    timeAVL.TimeStart();         // запуск времени
                    if (AVLtree.Find(Convert.ToInt32(DataInput.Text)) == null)
                    {
                        timeAVL.FindTimeStop();          // остановка времени
                        result = "Элемент не найден!";
                        DrawAVLTree(AVLtree, null);
                    }
                    else
                    {
                        timeAVL.FindTimeStop();          // остановка времени
                        result = "Элемент найден!";
                        DrawAVLTree(AVLtree, Convert.ToInt32(DataInput.Text));
                    }
                    break;

                case 1:
                    timeBP.TimeStart();         // запуск времени
                    if (BinaryTree.Find(Convert.ToInt32(DataInput.Text)) == null)
                    {
                        timeBP.FindTimeStop();          // остановка времени
                        result = "Элемент не найден!";
                        DrawBTree(BinaryTree, null);
                    }
                    else
                    {
                        timeBP.FindTimeStop();          // остановка времени
                        result = "Элемент найден!";
                        DrawBTree(BinaryTree, Convert.ToInt32(DataInput.Text));
                    }
                    break;

                case 2:
                    timeBA.TimeStart();         // запуск времени
                    if (BinaryTreeA.Find(Convert.ToInt32(DataInput.Text)) == -1)
                    {
                        timeBA.FindTimeStop();          // остановка времени
                        result = "Элемент не найден!";
                        DrawBTree(BinaryTree, null);
                    }
                    else
                    {
                        timeBA.FindTimeStop();          // остановка времени
                        result = "Элемент найден!";
                        DrawBATree(1, Convert.ToInt32(DataInput.Text));
                    }
                    break;
                }
                gViewer.Graph = Mgraph;
                break;

            case 7:
                int max = 0;
                Mgraph = new Graph("Tree");
                switch (r)     // Поиск максимального значения
                {
                case 0:
                    max = (int)AVLtree.FindMax(AVLtree).Data;
                    DrawAVLTree(AVLtree, max);
                    break;

                case 1:
                    max = (int)BinaryTree.FindMax(BinaryTree).Data;
                    DrawBTree(BinaryTree, max);
                    break;

                case 2:
                    max = (int)BinaryTreeA.tree[BinaryTreeA.FindMax(1)];
                    DrawBATree(1, max);
                    break;
                }
                gViewer.Graph = Mgraph;
                result        = "Максимальный элемент = " + max;
                break;

            case 8:
                int min = 0;
                Mgraph = new Graph("Tree");
                switch (r)     // Поиск минимального значения
                {
                case 0:
                    min = (int)AVLtree.FindMin(AVLtree).Data;
                    DrawAVLTree(AVLtree, min);
                    break;

                case 1:
                    min = (int)BinaryTree.FindMin(BinaryTree).Data;
                    DrawBTree(BinaryTree, min);
                    break;

                case 2:
                    min = (int)BinaryTreeA.tree[BinaryTreeA.FindMin(1)];
                    DrawBATree(1, min);
                    break;
                }
                gViewer.Graph = Mgraph;
                result        = "Минимальный элемент = " + min;
                break;

            case 9:
                switch (r)     // Обход в глубину
                {
                case 0:
                    AVLtree.CLR(AVLtree, ref result, false);
                    break;

                case 1:
                    BinaryTree.CLR(BinaryTree, ref result, false);
                    break;

                case 2:
                    BinaryTreeA.CLR(1, ref result, false);
                    break;
                }
                break;

            case 10:
                switch (r)     // Обход в глубину
                {
                case 0:
                    AVLtree.LCR(AVLtree, ref result, false);
                    break;

                case 1:
                    BinaryTree.LCR(BinaryTree, ref result, false);
                    break;

                case 2:
                    BinaryTreeA.LCR(1, ref result, false);
                    break;
                }
                break;

            case 11:
                switch (r)     // Обход в глубину
                {
                case 0:
                    AVLtree.RCL(AVLtree, ref result, false);
                    break;

                case 1:
                    BinaryTree.RCL(BinaryTree, ref result, false);
                    break;

                case 2:
                    BinaryTreeA.RCL(1, ref result, false);
                    break;
                }
                break;

            case 12:
                switch (r)     // Обход в ширину
                {
                case 0:
                    AVLtree.Across(AVLtree, ref result, false);
                    break;

                case 1:
                    BinaryTree.Across(BinaryTree, ref result, false);
                    break;

                case 2:
                    BinaryTreeA.Across(1, ref result, false);
                    break;
                }
                break;

            case 13:
                switch (r)     // Зеркальное отражение дерева
                {
                case 0:
                    AVLtree.MirrorTree(AVLtree);
                    break;

                case 1:
                    BinaryTree.MirrorTree(BinaryTree);
                    break;

                case 2:
                    BinaryTreeA.MirrorTree(1);
                    break;
                }
                break;

            default:
                return;
            }
            if (k == 0 || k == 1 || k == 13) // Если внешний вид дерева изменился, то перерисовываем дерево
            {
                Mgraph = new Graph("Tree");
                switch (r)
                {
                case 0:
                    DrawAVLTree(AVLtree, null);
                    break;

                case 1:
                    DrawBTree(BinaryTree, null);
                    break;

                case 2:
                    DrawBATree(1, null);
                    break;
                }
                gViewer.Graph = Mgraph;
            }
            else
            {
                Results.Text = result;
            }
        }