Левый поворот AVL дерева

static void Main(string[] args)
        {
            AVL tree = new AVL();
            StreamWriter sw = new StreamWriter(@"output.txt");
            string[] lines = File.ReadAllLines(@"input.txt"); // массив из файла
            int line_count = Convert.ToInt32(lines[0]); // длина дерева
            int[,] mas = new int[line_count, 3]; // массив из которого образуем дерево
            if (lines[0] == "0") sw.WriteLine(0); // если число вершин 0 запишем 0
            else
            {
                for (int i = 1; i < lines.Length; i++) // формируем целочисленный массив для дерева
                {
                    string[] Temp = lines[i].Split(' ');
                    for (int j = 0; j < Temp.Length; j++)
                        mas[i - 1, j] = int.Parse(Temp[j]);
                }
                for (int i = 0; i < line_count; i++)
                {
                    tree.Add(mas[i, 0]); // заносим в дерево элементы массива, стоящие в 1 столбце 
                }
            }
 
            var array = AVL.LevelOrderTraversal(tree).ToArray(); // массив вершин (обход в ширину)
            string [] a = new string[line_count+1];
            a[0] = line_count.ToString();
            for (int i = 1; i < array.Length + 1; i++)
            {
                AVL.Node check = tree.Search(tree.root, Convert.ToInt32(array[i - 1].ToString()));
                int left_index = Array.IndexOf(array, check.left) +1;
                int right_index = Array.IndexOf(array, check.right) +1;
                a[i] += array[i-1].ToString()+" ";
                a[i] += left_index.ToString() + " ";
                a[i] += right_index.ToString() + " ";
            }
            foreach(var item in a)
            {
                sw.WriteLine(item);
                Console.WriteLine(item);
            }
            sw.Close();
        }
 class AVL
    {
        public class Node
        {
            public int data;
            public Node left;
            public Node right;
            public Node(int data)
            {
                this.data = data;
            }
            public override string ToString()
            {
                return $"{data}";
            }
        }
        public Node root;
        
        public void Add(int data) // добавление в дерево 
        {
            Node newItem = new Node(data);
            if (root == null)
            {
                root = newItem;
            }
            else
            {
                root = RecursiveInsert(root, newItem);
            }
        }
 
        public static IEnumerable<Node> LevelOrderTraversal(AVL tree)
        {
            if (tree.root == null)
                yield break;
 
            var queue = new Queue<Node>();
            queue.Enqueue(tree.root);
 
            while (queue.Count > 0)
            {
                var node = queue.Dequeue();
                yield return node;
 
                if (node.left != null)
                    queue.Enqueue(node.left);
                if (node.right != null)
                    queue.Enqueue(node.right);
            }
        }
 
        private Node RecursiveInsert(Node current, Node n) // добавление в дерево через рекурсию
        {
            if (current == null)
            {
                current = n;
                return current;
            }
            else if (n.data < current.data)
            {
                current.left = RecursiveInsert(current.left, n);
                current = balance_tree(current);
            }
            else if (n.data > current.data)
            {
                current.right = RecursiveInsert(current.right, n);
                current = balance_tree(current);
            }
            return current;
        }
        public Node Search(Node x, int value) // поиск элемента в дереве 
        {
            if (x == null) return null;
            if (x.data == value) return x;
            if (value <= x.data)
            {
                // left
                if (x.left != null)
                    return Search(x.left, value); // рекурсивный поиск влево
                else
                {
                    return null; // не найден
                }
            }
            else
            {
                //right
                if (x.right != null)
                    return Search(x.right, value);// рекурсивный поиск вправо
                else
                {
                    return null; // не найден
                }
            }
        }
        private Node balance_tree(Node current) // баланс вершины которую заносим в дерево
        {
            int b_factor = balance_factor(current);
            if (b_factor > 1)
            {
                if (balance_factor(current.left) > 0)
                {
                    current = RotateLL(current);
                }
                //else
                //{
                //    current = RotateLR(current);
                //}
            }
            else if (b_factor < -1)
            {
                if (balance_factor(current.right) > 0)
                {
                    current = RotateRL(current);
                }
                else
                {
                    current = RotateRR(current);
                }
            }
            return current;
        }
         
               
      
        // балинсирвкa
        private int max(int l, int r)
        {
            return l > r ? l : r;
        }
        private int getHeight(Node current)
        {
            int height = 0;
            if (current != null)
            {
                int l = getHeight(current.left);
                int r = getHeight(current.right);
                int m = max(l, r);
                height = m + 1;
            }
            return height;
        }
        private int balance_factor(Node current)
        {
            int l = getHeight(current.left);
            int r = getHeight(current.right);
            int b_factor = l - r;
            return b_factor;
        }
        private Node RotateRR(Node parent)
        {
            Node pivot = parent.right;
            parent.right = pivot.left;
            pivot.left = parent;
            return pivot;
        }
        private Node RotateLL(Node parent)
        {
            Node pivot = parent.left;
            parent.left = pivot.right;
            pivot.right = parent;
            return pivot;
        }
        private Node RotateLR(Node parent)
        {
            Node pivot = parent.left;
            parent.left = RotateRR(pivot);
            return RotateLL(parent);
        }
        private Node RotateRL(Node parent)
        {
            Node pivot = parent.right;
            parent.right = RotateLL(pivot);
            return RotateRR(parent);
        }
 
       
    }