/// <summary>
        /// Восстанавливает из файла два дерева
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="tree1"></param>
        /// <param name="tree2"></param>
        /// <returns></returns>
        public static int RestoreFromFile(string fileName, out CartesianTree <T> tree1, out CartesianTree <T> tree2)
        {
            tree1 = new CartesianTree <T>();
            tree2 = new CartesianTree <T>();
            try
            {
                Node <T> root1;
                Node <T> root2;
                int      a = Node <T> .RestoreFromFile(out root1, out root2, fileName);

                tree1.Root = root1;
                tree2.Root = root2;
                return(a);
            }
            catch (InvalidDataException e)
            {
                Console.WriteLine(e.Message);
                Console.ReadKey();
                return(-1);
            }
            catch (FileNotFoundException e)
            {
                Console.WriteLine(e.Message);
                Console.ReadKey();
                return(-1);
            }
        }
        //
        // Сохранить в input.dat (нерекурсивный алгоритм обхода дерева по принципу лево-корень-право)
        //
        /// <summary>
        /// Сохранит дерево в одну строку в указанный файл (добавление)
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="fileName"></param>
        public static void SaveTreeInFile(CartesianTree <int> tree, string fileName)
        {
            StreamWriter        writer      = new StreamWriter(fileName, true);
            Stack <Node <int> > stack       = new Stack <Node <int> >();
            Node <int>          currentNode = tree.Root;

            writer.Write("\n$;");
            while (!(currentNode == null && stack.Count == 0))
            {
                if (currentNode != null)
                {
                    stack.Push(currentNode);
                    currentNode = currentNode.LeftSubTree;
                }
                else
                {
                    currentNode = stack.Pop();
                    writer.Write(currentNode.X + " " + currentNode.Y + ";");
                    currentNode = currentNode.RightSubTree;
                }
            }
            writer.Write("$\n");
            writer.Close();
        }
        /// <summary>
        /// Добавит таблицу ссылок для данного декаротова дерева в укзанный файл
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="fileName"></param>
        public static void AddLinksTableToFile(CartesianTree <int> tree, string fileName)
        {
            if (tree.Root == null)
            {
                return;
            }
            StreamWriter writer = new StreamWriter(fileName, true);

            if (writer == null)
            {
                throw new FileNotFoundException("Файл " + fileName + " не найден");
            }
            Stack <Node <int> > stack       = new Stack <Node <int> >();
            Node <int>          currentNode = tree.Root;

            writer.WriteLine("\n");
            writer.WriteLine("==========Корень данного дерева==========\n");
            if (tree.Root == null)
            {
                Console.WriteLine("NULL");
                return;
            }
            else
            {
                writer.WriteLine("Поле data = " + tree.Root.Data);
                writer.WriteLine("Ключ Х = " + tree.Root.X);
                writer.WriteLine("Приоритет = " + tree.Root.Y);
                writer.Write("Потомок слева = ");
                if (tree.Root.LeftSubTree != null)
                {
                    writer.WriteLine("ключ Х = " + tree.Root.LeftSubTree.X + "приоритет Y = " + tree.Root.LeftSubTree.Y);
                }
                else
                {
                    writer.WriteLine("не существует");
                }
                writer.Write("Потомок справа = ");
                if (tree.Root.RightSubTree != null)
                {
                    writer.WriteLine("ключ Х = " + tree.Root.RightSubTree.X + "приоритет Y = " + tree.Root.RightSubTree.Y + "\n\n");
                }
                else
                {
                    writer.WriteLine("не существует\n\n");
                }
            }
            writer.WriteLine("\n");
            writer.WriteLine("================Таблица ссылок в данном экземпляре Декартова дерева==================\n");
            writer.WriteLine("| Ключ + (приоритет)|  Левый потомок|  Правый потомок|\n");
            while (!(currentNode == null && stack.Count == 0))
            {
                if (currentNode != null)
                {
                    stack.Push(currentNode);
                    currentNode = currentNode.LeftSubTree;
                }
                else
                {
                    currentNode = stack.Pop();
                    writer.Write("  " + currentNode.X + " \t" + "(" + currentNode.Y + ")" + " \t\t");
                    if (currentNode.LeftSubTree != null)
                    {
                        writer.Write("  " + currentNode.LeftSubTree.X + " \t" + "(" + currentNode.LeftSubTree.Y + ")" + " \t\t");
                    }
                    else
                    {
                        writer.Write("\t нет\t\t");
                    }
                    if (currentNode.RightSubTree != null)
                    {
                        writer.Write("  " + currentNode.RightSubTree.X + " \t" + "(" + currentNode.RightSubTree.Y + ")" + " \n\n" + writer.NewLine);
                    }
                    else
                    {
                        writer.Write("\t нет\n\n" + writer.NewLine);
                    }
                    currentNode = currentNode.RightSubTree;
                }
            }
            writer.Close();
        }
Пример #4
0
        static void Main(string[] args)
        {
            bool goOut = false;
            CartesianTree <int> tree1 = new CartesianTree <int>();
            CartesianTree <int> tree2 = new CartesianTree <int>();

            do
            {
                switch (Subroutines.PrintMenu())
                {
                //
                // c - создать деревья и заполнить их случайными величинами (по х)
                //
                case 'c':
                {
                    if (!tree1.IsEmpty())
                    {
                        tree1 = new CartesianTree <int>();
                    }
                    if (!tree2.IsEmpty())
                    {
                        tree2 = new CartesianTree <int>();
                    }
                    int elemNum = 0;
                    do
                    {
                        do
                        {
                            Console.Write("Сколько элементов будет в первом дереве (не более 50 и не менее 1) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out elemNum));
                    } while (elemNum > 50 || elemNum < 1);
                    Random random = new Random();
                    for (int i = 0; i < elemNum; i++)
                    {
                        tree1.Add(random.Next(0, 100), random.Next(0, 10000));
                    }

                    do
                    {
                        do
                        {
                            Console.Write("Сколько элементов будет во втором дереве (не более 50 и не менее 1) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out elemNum));
                    } while (elemNum > 50 || elemNum < 1);
                    for (int i = 0; i < elemNum; i++)
                    {
                        tree2.Add(random.Next(0, 100), random.Next(0, 10000));
                    }

                    StreamWriter writer = new StreamWriter("input.dat");
                    writer.WriteLine("//==========Дерево 1============//\n");
                    writer.Close();

                    Subroutines.SaveTreeInFile(tree1, "input.dat");

                    writer = new StreamWriter("input.dat", true);
                    writer.WriteLine(writer.NewLine + "\r\n//==========Дерево 2============//\n");
                    writer.Close();

                    Subroutines.SaveTreeInFile(tree2, "input.dat");
                    Console.WriteLine("Деревья сформированы. Нажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // b - восстановить деревья из файла input.dat
                //
                case 'b':
                {
                    if (!tree1.IsEmpty())
                    {
                        tree1 = new CartesianTree <int>();
                    }
                    if (!tree2.IsEmpty())
                    {
                        tree2 = new CartesianTree <int>();
                    }
                    try
                    {
                        CartesianTree <int> .RestoreFromFile("input.dat", out tree1, out tree2);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Что-то мне совсем плохо");
                        Console.ReadKey();
                        Environment.Exit(-2);
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // d - удалить узлы, принадлежащие заданному отрезку
                //
                case 'd':
                {
                    if (tree1.IsEmpty() || tree2.IsEmpty())
                    {
                        Console.WriteLine("Одно или два дерева являются пустыми. Нажмите что-нубудь");
                        Console.ReadKey();
                        break;
                    }
                    int x, y;
                    do
                    {
                        do
                        {
                            Console.Write("Задайте первую границу отрезка ");
                        } while (!Int32.TryParse(Console.ReadLine(), out x));

                        do
                        {
                            Console.Write("Задайте второую границу отрезка ");
                        } while (!Int32.TryParse(Console.ReadLine(), out y));
                    } while (x > y);
                    if (tree1.FindMax() < tree2.FindMax())
                    {
                        Console.WriteLine("\n\nУдаление из :");
                        Console.WriteLine("\n\n=======Дерево 2======\n\n");
                        tree2.GetRootInfo();
                        Console.WriteLine("Высота = " + tree2.Height);
                        Console.WriteLine("MAX = " + tree2.FindMax());
                        StreamWriter writer = new StreamWriter("output.dat");
                        writer.WriteLine("##############################################");
                        writer.WriteLine("               Было     (Дерево 2)");
                        writer.WriteLine("##############################################");
                        writer.Close();

                        Subroutines.AddLinksTableToFile(tree2, "output.dat");
                        tree2.DeleteFromSegment(x, y);

                        writer = new StreamWriter("output.dat", true);
                        writer.WriteLine("\n\n##############################################");
                        writer.WriteLine("               Стало    (Дерево 2)");
                        writer.WriteLine("##############################################");
                        writer.Close();
                        Subroutines.AddLinksTableToFile(tree2, "output.dat");
                    }
                    else
                    {
                        Console.WriteLine("\n\nУдаление из :");
                        Console.WriteLine("\n\n=======Дерево 1======\n\n");
                        tree1.GetRootInfo();
                        Console.WriteLine("Высота = " + tree1.Height);
                        Console.WriteLine("MAX = " + tree1.FindMax());
                        StreamWriter writer = new StreamWriter("output.dat");
                        writer.WriteLine("##############################################");
                        writer.WriteLine("               Было     (Дерево 1)");
                        writer.WriteLine("##############################################");
                        writer.Close();

                        Subroutines.AddLinksTableToFile(tree1, "output.dat");
                        tree1.DeleteFromSegment(x, y);

                        writer = new StreamWriter("output.dat", true);
                        writer.WriteLine("\n\n##############################################");
                        writer.WriteLine("               Стало    (Дерево 1)");
                        writer.WriteLine("##############################################");
                        writer.Close();
                        Subroutines.AddLinksTableToFile(tree1, "output.dat");
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // p - показать дерево (сделать обход, без связей)
                //
                case 'p':
                {
                    int whatTree;
                    do
                    {
                        do
                        {
                            Console.Write("\nКакое дерево показать? (1) или (2) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out whatTree));
                    } while (whatTree < 1 || whatTree > 2);
                    if (whatTree == 1)
                    {
                        if (tree1.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 1============");
                        Console.WriteLine("\nКорень\n");
                        tree1.GetRootInfo();
                        Console.WriteLine("Высота = " + tree1.Height);
                        Console.WriteLine("MAX = " + tree1.FindMax());

                        tree1.ShowTree();
                    }
                    else
                    {
                        if (tree2.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 2============");
                        Console.WriteLine("\nКорень\n");
                        tree2.GetRootInfo();
                        Console.WriteLine("Высота = " + tree2.Height);
                        Console.WriteLine("MAX = " + tree2.FindMax());

                        tree2.ShowTree();
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // r - показать таблицу связей дерева
                //
                case 'r':
                {
                    int whatTree;
                    do
                    {
                        do
                        {
                            Console.Write("\nКакое дерево показать? (1) или (2) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out whatTree));
                    } while (whatTree < 1 || whatTree > 2);
                    if (whatTree == 1)
                    {
                        Console.WriteLine("\n\n==========Дерево 1============");
                        if (tree1.ShowTreeLinks() == false)
                        {
                            Console.WriteLine("\nПроблемы! Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                    }
                    else
                    {
                        Console.WriteLine("\n\n==========Дерево 2============");
                        if (tree2.ShowTreeLinks() == false)
                        {
                            Console.WriteLine("\nПроблемы! Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // h - Получить высоту дерева
                //
                case 'h':
                {
                    int whatTree;
                    do
                    {
                        do
                        {
                            Console.Write("\nКакое дерево показать? (1) или (2) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out whatTree));
                    } while (whatTree < 1 || whatTree > 2);
                    if (whatTree == 1)
                    {
                        if (tree1.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 1============");
                        Console.WriteLine("\nВысота = " + tree1.Height + "\n");
                    }
                    else
                    {
                        if (tree2.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 2============");
                        Console.WriteLine("\nВысота = " + tree2.Height + "\n");
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // v - получить информацию о корне
                //
                case 'v':
                {
                    int whatTree;
                    do
                    {
                        do
                        {
                            Console.Write("\nКакое дерево показать? (1) или (2) ");
                        } while (!Int32.TryParse(Console.ReadLine(), out whatTree));
                    } while (whatTree < 1 || whatTree > 2);
                    if (whatTree == 1)
                    {
                        if (tree1.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 1============");
                        Console.WriteLine("\nКорень\n");
                        tree1.GetRootInfo();
                    }
                    else
                    {
                        if (tree2.IsEmpty())
                        {
                            Console.WriteLine("Дерево пусто. Нажмите что-нибудь");
                            Console.ReadKey();
                            break;
                        }
                        Console.WriteLine("\n\n==========Дерево 2============");
                        Console.WriteLine("\nКорень\n");
                        tree2.GetRootInfo();
                    }
                    Console.WriteLine("\nНажмите что-нибудь");
                    Console.ReadKey();
                    break;
                }

                //
                // ESC - выход
                //
                case (char)27:
                {
                    goOut = true;
                    break;
                }
                }
            } while (goOut == false);
        }