21 деревья 1, 2

//класс дерева
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace Myloyorrrr
{
    public class BinaryTree //класс, реализующий АТД «дерево бинарного поиска»
    {
        //вложенный класс, отвечающий за узлы и операции допустимы для дерева бинарного
        //поиска
        private class Node
        {
            public object inf; //информационное поле
            public Node left; //ссылка на левое поддерево
            public Node right; //ссылка на правое поддерево
                               //конструктор вложенного класса, создает узел дерева
            public Node(object nodeInf)
            {
                inf = nodeInf;
                left = null;
                right = null;
            }
            //добавляет узел в дерево так, чтобы дерево оставалось деревом бинарного поиска
            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);
                    }
                }
            }
            public static void Preorder(Node r) //прямой обход дерева
            {
                if (r != null)
                {
                    Console.Write("{0} ", r.inf);
                    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 int CountNodes(Node x)
            {
                int l = CountNodes(x.left);
                int r = CountNodes(x.right);

                return 1 + l + r;
            }

            private static int Height(Node node)
            {
                if (node == null)
                    return 0;

                return Math.Max(Height(node.left), Height(node.right)) + 1;
            }

            public static bool IsBalanced(Node node)
            {
                if (node == null)
                    return true;

                int leftHeight = Height(node.left);
                int rightHeight = Height(node.right);

                // Проверяем разницу высот левого и правого поддеревьев
                if (Math.Abs(leftHeight - rightHeight) <= 1 && IsBalanced(node.left) && IsBalanced(node.right))
                    return true;

                return false;
            }
            public static void PrintNodes(Node node, int currentlvl, int targetlvl, ref int cnt)
            {
                if (node == null)
                {
                    return;
                }
                if(currentlvl == targetlvl)
                {
                    cnt++;
                    return;
                }
                else if(currentlvl < targetlvl)
                {
                    cnt++;
                    PrintNodes(node.left, currentlvl + 1, targetlvl, ref cnt);
                    PrintNodes(node.right, currentlvl + 1, targetlvl, ref cnt);
                }
            }

            //поиск ключевого узла в дереве
            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);
                }
                else
                {
                    t.inf = tr.inf;
                    tr = tr.left;
                }
            }
            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);
                    }
                    else
                    {
                        if (((IComparable)(t.inf)).CompareTo(key) < 0)
                        {
                            Delete(ref t.right, key);
                        }
                        else
                        {
                            if (t.left == null)
                            {
                                t = t.right;
                            }
                            else
                            {
                                if (t.right == null)
                                {
                                    t = t.left;
                                }
                                else
                                {
                                    Del(t, ref t.left);
                                }
                            }
                        }
                    }
                }
            }
        } //конец вложенного класса
        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 double Check() // 1 деревья - подсчет среднего арифметического узлов, у которых есть два потомка
        {
            if (tree == null)
                return 0;

            int nodesCount = 0;
            int totalSum = 0;

            void LeftRight(Node node)
            {
                if (node.right != null && node.left == null)
                {
                    LeftRight(node.right);
                }
                else if (node.left != null && node.right == null)
                {
                    LeftRight(node.left);
                }
                else if (node.left != null && node.right != null)
                {
                    nodesCount++;
                    totalSum += (int)node.inf;
                    //Console.WriteLine((int)node.inf + " " + nodesCount);
                    LeftRight(node.left);
                    LeftRight(node.right);
                }
            }

            LeftRight(tree);

            return nodesCount == 0 ? 0 : (double)totalSum / nodesCount;
        }

        public void PrintNodes(int lvl) // 2 деревья - подсчет количества узлов, не ниже lvl уровня (lvl и выше)
        {
            if (tree == null)
            {
                Console.WriteLine("Дерево пусто");
                return;
            }
            int cnt = 0;
            Node.PrintNodes(tree, 0, lvl, ref cnt);
            Console.WriteLine($"Количество узлов не ниже {lvl}:" + " " + cnt);
        }

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


//программка запуска
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Myloyorrrr
{
    internal class Program
    {
        static void Main()
        {
            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++;
                    }
                }

            }
            //1 деревья
            double average = lipa.Check();
            Console.WriteLine("Среднее арифметическое значений узлов с двумя потомками: " + average);
            Console.WriteLine();

            //2 деревья
            Console.Write("Введите уровень: ");
            int k = int.Parse(Console.ReadLine());
            lipa.PrintNodes(k);
            Console.WriteLine();

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