деревья 3

// класс деревьев
using System;

namespace Myloyorrrr
{
    public class BinaryTree //класс, реализующий АТД «дерево бинарного поиска»
    {
        //вложенный класс, отвечающий за узлы и операции допустимы для дерева бинарного
        //поиска
        private class Node
        {
            public object inf; //информационное поле
            public Node left; //ссылка на левое поддерево
            public Node right; //ссылка на правое поддерево
            public int height; //высота узла

            //конструктор вложенного класса, создает узел дерева
            public Node(object nodeInf)
            {
                inf = nodeInf;
                left = null;
                right = null;
                height = 1;
            }
            public static int Height(Node node)
            {
                if (node == null)
                    return 0;
                return node.height;
            }

            public void NewHeight() //пересчет высоты
            {
                this.height = (Math.Max(Height(this.right), Height(this.left)) + 1);
            }


            //добавляет узел в дерево так, чтобы дерево оставалось деревом бинарного поиска
            public static void Add(ref Node r, object nodeInf)
            {
                if (r == null)
                {
                    r = new Node(nodeInf);
                }
                else
                {
                    if (((IComparable)(r.inf)).CompareTo(nodeInf) > 0)
                    {
                        Add(ref r.left, nodeInf);
                    }
                    else
                    {
                        Add(ref r.right, nodeInf);
                    }
                    r.NewHeight();
                }
            }
            public static void Preorder(Node r) //прямой обход дерева
            {
                if (r != null)
                {
                    Console.WriteLine("{0}, высота: {1}.", r.inf, r.height);
                    Preorder(r.left);
                    Preorder(r.right);
                }
            }
            public static void Inorder(Node r) //симметричный обход дерева
            {
                if (r != null)
                {
                    Inorder(r.left);
                    Console.Write("{0} ", r.inf);
                    Inorder(r.right);
                }
            }
            public static void Postorder(Node r) //обратный обход дерева
            {
                if (r != null)
                {
                    Postorder(r.left);
                    Postorder(r.right);
                    Console.Write("{0} ", r.inf);
                }
            }

            //поиск ключевого узла в дереве
            public static void Search(Node r, object key, out Node item)
            {
                if (r == null)
                {
                    item = null;
                }
                else
                {
                    if (((IComparable)(r.inf)).CompareTo(key) == 0)
                    {
                        item = r;
                    }
                    else
                    {
                        if (((IComparable)(r.inf)).CompareTo(key) > 0)
                        {
                            Search(r.left, key, out item);
                        }
                        else
                        {
                            Search(r.right, key, out item);
                        }
                    }
                }
            }
            //методы Del и Delete позволяют удалить узел в дереве так, чтобы дерево при этом
            //оставалось деревом бинарного поиска
            private static void Del(Node t, ref Node tr)
            {
                if (tr.right != null)
                {
                    Del(t, ref tr.right);
                    t.NewHeight();
                }
                else
                {
                    t.inf = tr.inf;
                    tr = tr.left;
                    tr.NewHeight();
                }
            }
            public static void Delete(ref Node t, object key)
            {
                if (t == null)
                {
                    throw new Exception("Данное значение в дереве отсутствует");
                }
                else
                {
                    if (((IComparable)(t.inf)).CompareTo(key) > 0)
                    {
                        Delete(ref t.left, key);
                        t.NewHeight();
                    }
                    else
                    {
                        if (((IComparable)(t.inf)).CompareTo(key) < 0)
                        {
                            Delete(ref t.right, key);
                            t.NewHeight();
                        }
                        else
                        {
                            if (t.left == null)
                            {
                                t = t.right;
                            }
                            else
                            {
                                if (t.right == null)
                                {
                                    t = t.left;
                                }
                                else
                                {
                                    Del(t, ref t.left);
                                    t.NewHeight();
                                }
                            }
                        }
                    }
                }
            }
            public static bool IsBalanced(Node node)
            {
                if (node == null)
                    return true;

                if (Math.Abs(Height(node.left) - Height(node.right)) <= 1 && IsBalanced(node.left) && IsBalanced(node.right))
                {
                    return true;
                }
                return false;
            }

        }
        //конец вложенного класса
        Node tree; //ссылка на корень дерева
                   //свойство позволяет получить доступ к значению информационного поля корня дерева

        public object Inf
        {
            set { tree.inf = value; }
            get { return tree.inf; }
        }
        public BinaryTree() //открытый конструктор
        {
            tree = null;
        }
        private BinaryTree(Node r) //закрытый конструктор
        {
            tree = r;
        }
        public void Add(object nodeInf) //добавление узла в дерево
        {
            Node.Add(ref tree, nodeInf);
        }
        //организация различных способов обхода дерева
        public void Preorder()
        {
            Node.Preorder(tree);
        }
        public void Inorder()
        {
            Node.Inorder(tree);
        }
        public void Postorder()
        {
            Node.Postorder(tree);
        }

        //поиск ключевого узла в дереве
        public BinaryTree Search(object key)
        {
            Node r;
            Node.Search(tree, key, out r);
            BinaryTree t = new BinaryTree(r);
            return t;
        }
        //удаление ключевого узла в дереве
        public void Delete(object key)
        {
            Node.Delete(ref tree, key);
        }

        public bool Balance() //3 деревья - проверяем сбалансировано ли дерево
        {
            return Node.IsBalanced(tree);
        }
    }
}
// класс очередь
using System;

namespace Myloyorrrr
{
    public class Queue
    {
        private class Node //вложенный класс, реализующий базовый элемент очереди
        {
            private object inf;
            private Node next;
            public Node(object nodeInfo)
            {
                inf = nodeInfo;
                next = null;
            }
            public Node Next
            {
                get { return next; }
                set { next = value; }
            }
            public object Inf
            {
                get { return inf; }
                set { inf = value; }
            }
        } //конец класса Node
        private Node head;
        private Node tail;
        public Queue()
        {
            head = null;
            tail = null;
        }
        public void Add(object nodeInfo)
        {
            Node r = new Node(nodeInfo);
            if (head == null)
            {
                head = r;
                tail = r;
            }
            else
            {
                tail.Next = r;
                tail = r;
            }
        }
        public object Take()
        {
            if (head == null)
            {
                throw new Exception("Очередь пуста.");
            }
            else
            {
                Node r = head; //1
                head = head.Next; //2
                if (head == null) //3
                {
                    tail = null; //4
                }
                return r.Inf; //5
            }
        }
        public bool IsEmpty
        {
            get
            {
                if (head == null)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
    }
}


// осн прога
using System;
using System.IO;

namespace Myloyorrrr
{
    internal class Program
    {
        static void Main()
        {
            //Graph G = new Graph("C:/Настя/книит/in.txt");
            //G.Show();
            //Console.WriteLine();
            //Console.WriteLine("Введите первую вершину:");
            //int a = int.Parse(Console.ReadLine());
            //Console.WriteLine("Введите вторую вершину:");
            //int b = int.Parse(Console.ReadLine());
            //Console.WriteLine("Введите вершину, через которую нельзя пройти:");
            //int d = int.Parse(Console.ReadLine());
            //Console.WriteLine();
            //G.Myloyo_find(a-1, b-1, d-1);


            //// 1 задача: подсчитать смежные вершины с данной вершиной
            //Console.Write("Введите номер вершины: ");
            //int v = int.Parse(Console.ReadLine());
            //G.Adjacent(v);

            //// 2 задача: определить все пары вершин, для которых существует путь длиной не более L
            //Console.Write("Введите требуемую длину пути: ");
            //int L = int.Parse(Console.ReadLine());
            //G.Floyd_new(L);

            BinaryTree lipa = new BinaryTree();
            int n = 0;

            //Чтение последовательности чисел из файла input.txt и добавление их в дерево
            using (StreamReader f = new StreamReader("C:/Настя/книит/in.txt"))
            {
                string line;
                while ((line = f.ReadLine()) != null)
                {
                    string[] text = line.Split(' ');
                    for (int i = 0; i < text.Length; i++)
                    {
                        int num = int.Parse(text[i]);
                        lipa.Add(num);
                        n++;
                    }
                }

            }

            lipa.Preorder();

            //3 деревья
            bool IsBalance = lipa.Balance();
            if (IsBalance)
            {
                Console.WriteLine("Дерево является сбалансированным");
            }
            else
            {
                Console.WriteLine("Дерево не является сбалансированным");
            }
        }
    }
}