/// <summary>
        /// Считывание бинарного дерева из файла
        /// </summary>
        /// <returns></returns>
        public BinaryTreeArray ReadFile()
        {
            OpenFileDialog open  = new OpenFileDialog(); // save - имя компонента SaveFileDialog
            string         Fname = "";                   // для имени файла

            // задание начальной директории
            open.InitialDirectory = @"С:\";
            // задание свойства Filter
            open.Filter = "txt files (*.txt)|*.txt";
            // задание свойства FilterIndex – выбор типа файла
            open.FilterIndex = 2;
            // свойство Title - название окна диалога выбора файла
            open.Title = "Открыть файл";

            if (open.ShowDialog() == DialogResult.OK)
            { // получаем имя файла для сохранения данных
                Fname = open.FileName;
                FileStream fs = new FileStream(Fname, FileMode.Open, FileAccess.Read);

                if (fs != null) // в случае успеха создания объекта fs
                {               // создаем объект типа StreamReader и
                  // ассоциируем его с объектом fs

                    StreamReader r = new StreamReader(fs);
                    // коллекция для данных из файла
                    List <int> array = new List <int>();
                    int        i     = 0;
                    while (!r.EndOfStream) // пока нет конца потока
                    {
                        try
                        {
                            array.Add(Convert.ToInt32(r.ReadLine()));
                        }
                        catch (Exception)
                        {
                            MessageBox.Show("Ошибка чтения массива из файла!", "Error");
                        }
                    }
                    r.Close(); fs.Close();
                    BinaryTreeArray newTree = new BinaryTreeArray();
                    for (int j = 0; j < array.Count; j++)
                    {
                        newTree.Insert(array[j]);
                    }
                    return(newTree);
                }
                else
                {
                    MessageBox.Show("Ошибка чтения из файла!", "Ошибка"); return(this);
                }
            }
            else
            {
                return(this);
            }
        }
        /// <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;
            }
        }