21.1

using System;
using System.IO;
namespace practice
{
    public class BinaryTree
    {
        private class Node
        {
            public int inf;
            public Node left;
            public Node right;
            public Node(int nodeInf)
            {
                inf = nodeInf;
                left = null;
                right = null;
            }
            public static void Add(ref Node r, int 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 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);
                        }
                    }
                }
            }
            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);
                                }
                            }
                        }
                    }
                }
            }
            public static void RotationRigth(ref Node t)
            {
                Node x = t.left;
                t.left = x.right;
                x.right = t;
                t = x;
            }
            public static void RotationLeft(ref Node t)
            {
                Node x = t.right;
                t.right = x.left;
                x.left = t;
                t = x;
            }
            public static void InsertToRoot(ref Node t, int item)
            {
                if (t == null)
                {
                    t = new Node(item);
                }
                else
                    if (((IComparable)(t.inf)).CompareTo(item) > 0)
                    {
                        InsertToRoot(ref t.left, item);
                        RotationRigth(ref t);
                    }
                    else
                    {
                        InsertToRoot(ref t.right, item);
                        RotationLeft(ref t);
                    }
            }
            public static Node JoinTree(Node a, Node b)
            {
                if (b == null)
                    return a;
                if (a == null)
                    return b;
                InsertToRoot(ref b, a.inf);
                b.left = JoinTree(a.left, b.left);
                b.right = JoinTree(a.right, b.right);
                return b;
            }
            /*public static void InsertRandom(ref Node r, object nodeInf, Random rnd)
            {
                if (r == null) //если узел пустой, то производим создаем узел-лист
                {
                    r = new Node(nodeInf);
                } else //иначе, если достигается вероятность 1/(N+1), то производим вставку в корень
                {
                    if (rnd.Next() < int.MaxValue / (r.counter + 1))
                    {
                        InsertToRoot(ref r, nodeInf);
                    } else //иначе продолжаем рекурсивный поиск местоположения нового узла
                    {
                        r.counter++;
                        if (((IComparable)(r.inf)).CompareTo(nodeInf) > 0)
                        {
                            Add(ref r.left, nodeInf);
                        } else
                        {
                            Add(ref r.rigth, nodeInf);
                        }
                    }
                }
            }
        public static void Part(ref Node t, int k)
            {
            int x = (t.left == null) ? 0 : t.left.counter;
            if (x > k)
            {
                Part(ref t.left, k);
                RotationRigth(ref t);
            }
            if (x < k)
            {
                Part(ref t.rigth, k - x - 1);
                RotationLeft(ref t);
            }
        }
            public static void Balancer(ref Node t)
        {
            if (t == null || t.counter == 1) return; //если дерево пустое или узел-лист, то
            //балансировка закончена
            Part(ref t, t.counter / 2); //иначе вызываем метод, который помещает к-тый узел в
            //корень дерева (к= t.counter / 2)
            //затем балансируем левое и правое поддерево
            Balancer(ref t.left);
            Balancer(ref t.rigth);
        }*/
            public static void Average(Node r)
            {
                if (r!=null)
                {
                    if (r.inf >= 0)
                    {
                        sum += (float)r.inf;
                        cnt++;
                    }
                    Average (r.left);
                    Average (r.right);
                }

            }

        }
        public static float sum = 0;
        public static int cnt = 0;
        Node tree;
        public int Inf
        {
            set
            {
                tree.inf=value;
            }
            get
            {
                return tree.inf;
            }
        }
        public BinaryTree()
        {
            tree=null;
        }
        private BinaryTree(Node r)
        {
            tree=r;
        }
        public void Add(int 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 void InsertToRoot(int item)
        {
            Node.InsertToRoot(ref tree, item);
        }
        public void JoinTree(ref BinaryTree b)
        {
            b = new BinaryTree(Node.JoinTree(this.tree, b.tree));
        }
        /*public void InsertRandom(object nodeInf)
        {
            Random rnd = new Random();
            Node.InsertRandom(ref tree, nodeInf, rnd);
        }
        public void Balancer()
        {
            Node.Balancer(ref tree);
        }*/
        public void Average()
        {
            Node.Average(tree);
            Console.WriteLine("\nСреднее арифметическое положительных узлов: {0}", sum/cnt);
        }
    }

class Program
{

    static void Main()
    {
        BinaryTree tree = new BinaryTree();
        using (StreamReader input = new StreamReader("C:/Users/CryDone/Desktop/practice/input.txt"))
        {
            string line = input.ReadToEnd();
            string[] data = line.Split(' ');
            foreach (string item in data)
            {
                tree.Add(int.Parse(item));
            }
        }
        tree.Preorder();
        tree.Average();
        Console.ReadKey();
    }
}
}