Pr15R3

Program.cs____________________

using System;
using System.IO;

namespace test
{
    class Program
    {
        static BinaryTree myTree = new BinaryTree ();

        public static void Main (string[] args)
        {
            string[] content = File.ReadAllLines (@"../../input.txt");

            foreach (string line in content)
            {
                string[] data = line.Split (' ');
                myTree.Add (new Subscriber(int.Parse (data [0]), data [1], data [2], data [3]));
            }

            ShowTree ();

        }

        private static void ShowTree()
        {
            foreach (Subscriber subscriber in myTree.GetData(false))
            {
                Console.Write("{0} {1} {2} {3} ", subscriber.Id, subscriber.Name, subscriber.Number, subscriber.Tariff);
                Console.WriteLine();
            }
        }
    }
}

BinaryTree.cs_______________________
using System.Linq;

namespace test
{
    class BinaryTree
    {
        private Node root;

        public class Node
        {
            public Subscriber subscriber;
            public Node left;
            public Node right;
            public int children;

            public Node(Subscriber subscriber)
            {
                this.subscriber = subscriber;
                this.left = null;
                this.right = null;
                this.children = 1;
            }
        }

        public BinaryTree()
        {
            this.root = null;
        }

        public void Add(Subscriber subscriber)
        {
            Add(ref root, subscriber);
            Balancer();
        }

        private void Add(ref Node node, Subscriber newCome)
        {
            if (node == null)
            {
                node = new Node(newCome);
            }
            else
            {
                node.children++;
                if (node.subscriber.Id > newCome.Id)
                {
                    Add(ref node.left, newCome);
                }
                else
                {
                    Add(ref node.right, newCome);
                }
            }
        }

        private int CalcChildren(ref Node node)
        {
            if (node != null)
            {
                node.children = CalcChildren(ref node.left) + CalcChildren(ref node.right) + 1;
                return node.children;
            }
            else
            {
                return 0;
            }
        }

        public void Delete(int id)
        {
            Delete(ref root, id);
            Balancer(ref root);
            CalcChildren(ref root);
        }

        private void Delete(ref Node node, int id)
        {
            if (node != null)
            {
                if (node.subscriber.Id > id)
                {
                    Delete(ref node.left, id);
                }
                else if (node.subscriber.Id < id)
                {
                    Delete(ref node.right, id);
                }
                else
                {
                    if (node.left == null)
                    {
                        node = node.right;
                    }
                    else if (node.right == null)
                    {
                        node = node.left;
                    }
                    else
                    {
                        Node tmp = node.left;
                        Delete(node, ref tmp);
                    }
                }
            }
        }

        private void Delete(Node node, ref Node tmp)
        {
            if (tmp.right != null)
            {
                Delete(node, ref tmp.right);
            }
            else
            {
                node.subscriber.Id = tmp.subscriber.Id;
                tmp = tmp.left;
            }
        }

        public void Balancer()
        {
            Balancer(ref root);
        }

        private void Balancer(ref Node node)
        {
            if (node == null || node.children == 1)
                return;


            //Console.WriteLine(node == null);

            Part(ref node, node.children / 2);

            Balancer(ref node.left);
            Balancer(ref node.right);
        }

        private void Part(ref Node node, int index)
        {

            int left = (node.left == null) ? 0 : node.left.children;
            if (left > index)
            {
                Part(ref node.left, index);
                RotationRight(ref node);
            }
            if (left < index)
            {
                Part(ref node.right, index - left - 1);
                RotationLeft(ref node);
            }
        }

        private void RotationRight(ref Node node)
        {
            Node tmp = node.left;
            node.left = tmp.right;
            tmp.right = node;

            Count(ref node);
            Count(ref tmp);

            node = tmp;
        }

        private void RotationLeft(ref Node node)
        {
            Node tmp = node.right;
            node.right = tmp.left;
            tmp.left = node;

            Count(ref node);
            Count(ref tmp);

            node = tmp;
        }

        public void Count(ref Node node)
        {
            node.children = 1;

            if (node.left != null)
            {
                node.children += node.left.children;
            }

            if (node.right != null)
            {
                node.children += node.right.children;
            }
        }


        public bool IsBalanced()
        {
            bool answer = true;
            IsBalanced(ref root, ref answer);
            return answer;
        }

        private void IsBalanced(ref Node node, ref bool answer)
        {
            if (node != null)
            {
                int left = (node.left != null)   ? node.left.children  : 0;
                int right = (node.right != null) ? node.right.children : 0;

                if (Math.Abs(left - right) > 1)
                {
                    answer = false;
                }
                IsBalanced(ref node.left, ref answer);
                IsBalanced(ref node.right, ref answer);
            }
        }

        public List<Subscriber> GetData(bool sorted)
        {
            List<Subscriber> list = new List<Subscriber>();
            if (sorted)
            {
                GetSortedData(ref root, ref list);
            }
            else
            {
                GetData(ref root, ref list);
            }
            return list;
        }

        private void GetSortedData(ref Node node, ref List<Subscriber> list)
        {
            if (node != null)
            {
                GetSortedData(ref node.left, ref list);

                list.Add(node.subscriber);

                GetSortedData(ref node.right, ref list);
            }
        }

        private void GetData(ref Node node, ref List<Subscriber> list)
        {
            if (node != null)
            {
                list.Add(node.subscriber);

                GetData(ref node.left, ref list);

                GetData(ref node.right, ref list);
            }
        }

        public Subscriber findByNumber(String number)
        {
            Subscriber subscriber = null;

            findByNumber(ref root, ref subscriber, number);

            return subscriber;
        }

        private void findByNumber(ref Node node, ref Subscriber subscriber, String number)
        {
            if (node != null)
            {
                if (node.subscriber.Number.Equals(number))
                {
                    subscriber = node.subscriber;
                }

                findByNumber(ref node.left, ref subscriber, number);
                findByNumber(ref node.right, ref subscriber, number);
            }
        }

        public String getMostPopularTariff()
        {
            List<String> list = new List<string>();

            getMostPopularTariff(ref root, ref list);

            return list.GroupBy(str => str).OrderByDescending(str => str.Count()).FirstOrDefault().Key;
        }

        private void getMostPopularTariff(ref Node node, ref List<String> list)
        {
            if (node != null)
            {
                list.Add(node.subscriber.Tariff);

                getMostPopularTariff(ref node.left, ref list);
                getMostPopularTariff(ref node.right, ref list);
            }
        }

        public int getMaxId()
        {
            int max = int.MinValue;

            getMaxId(ref root, ref max);

            return max;
        }

        private void getMaxId(ref Node node, ref int max)
        {
            if (node != null)
            {
                max = Math.Max(max, node.subscriber.Id);

                getMaxId(ref node.left, ref max);
                getMaxId(ref node.right, ref max);
            }
        }
    }
}


Subscriber.cs____________________________________________________
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test
{
    class Subscriber
    {
        private int id;
        private String number;
        private String name;
        private String tariff;

        public Subscriber()
        { }

        public Subscriber(int id, String number, String name, String tariff)
        {
            this.id = id;
            this.number = number;
            this.name = name;
            this.tariff = tariff;
        }

        public int Id
        {
            get { return id; }
            set { id = value; }
        }

        public String Number
        {
            get { return number; }
            set { number = value; }
        }

        public String Name
        {
            get { return name; }
            set { name = value; }
        }

        public String Tariff
        {
            get { return tariff; }
            set { tariff = value; }
        }
    }
}