AVL-деревья - вставка узла

using System;
 
namespace MyCollections.Generic
{
    //Класс узла AVL-дерева.
    public class AVLTreeNode<T> : TreeNode<T>, IPrintable, ICloneableAs<AVLTreeNode<T>>
    {
        public new AVLTreeNode<T> left;
        public new AVLTreeNode<T> right;
        public new AVLTreeNode<T> parent;
        public int balance;
 
        public AVLTreeNode(T value = default(T), AVLTreeNode<T> left  = null, AVLTreeNode<T> right  = null, AVLTreeNode<T> parent = null)
        {
            this.value = value;
            this.left = left;
            this.right = right;
            this.parent = parent;
        }
 
        public new AVLTreeNode<T> CloneAs() => new AVLTreeNode<T>(value, left, right, parent);
 
        public override object Clone() => CloneAs();
    }
}

using System;
using System.Collections.Generic;
 
namespace MyCollections.Generic
{
    //Класс ALV-дерева поиска.
    public class AVLTree<T> : IPrintable
    {
        private AVLTreeNode<T> root;
 
        private AVLTreeNode<T> Find(AVLTreeNode<T> root, T x)
        {
            if (root != null)
            {
                if (Comparer.Compare(x, root.value) < 0)
                {
                    return Find(root.left, x);
                }
                else if (Comparer.Compare(x, root.value) > 0)
                {
                    return Find(root.right, x);
                }
                else
                {
                    return root;
                }
            }
            return null;
        }
 
        private void RotateRight(ref AVLTreeNode<T> root)
        {
            AVLTreeNode<T> leftNode = root.left;
            root.left = leftNode.right;
            root.left.parent = root;
 
            leftNode.parent = root.parent;
 
            leftNode.right = root;
            root.parent = leftNode;
 
            root = leftNode;
 
            root.right.balance = root.right.balance - 1 + Math.Min(-root.balance, 0);
            root.balance = root.balance - 1 + Math.Min(0, root.right.balance);
        }
 
        private void RotateLeft(ref AVLTreeNode<T> root)
        {
            AVLTreeNode<T> rightNode = root.right;
            root.right = rightNode.left;
            root.right.parent = root;
 
            rightNode.parent = root.parent;
 
            rightNode.left = root;
            root.parent = rightNode;
 
            root = rightNode;
 
            root.left.balance = root.left.balance + 1 - Math.Min(0, -root.balance);
            root.balance = root.balance + 1 + Math.Max(root.left.balance, 0);
        }
 
        private void RotateRightLeft(ref AVLTreeNode<T> root)
        {
            RotateRight(ref root.right);
            RotateLeft(ref root);
        }
 
        private void RotateLeftRight(ref AVLTreeNode<T> root)
        {
            RotateLeft(ref root.left);
            RotateRight(ref root);
        }
 
        private void Insert(AVLTreeNode<T> previous, ref AVLTreeNode<T> root, T x)
        {
            if (root == null)
            {
                root = new AVLTreeNode<T>(x);
                root.parent = previous;
            }
            else
            {
                if (Comparer.Compare(root.value, x) > 0)
                {
                    Insert(root, ref root.left, x);
                }
                else if (Comparer.Compare(root.value, x) < 0)
                {
                    Insert(root, ref root.right, x);
                }
                else
                {
                    return;
                }
            }
        }
 
        private void GetStringRepresentation(AVLTreeNode<T> root, ref string representation)
        {
            if (root != null)
            {
                representation += $"{root.value}, ";
                GetStringRepresentation(root.left, ref representation);
                GetStringRepresentation(root.right, ref representation);
            }
        }
 
        public IComparer<T> Comparer { get; private set; }
        public AVLTreeNode<T> Root => root;
        public int Count { get; private set; }
 
        public AVLTree(IComparer<T> comparer)
        {
            Comparer = comparer;
        }
 
        public AVLTree() : this(Comparer<T>.Default)
        {
        }
 
        public string GetStringRepresentation()
        {
            string representation = "{";
            GetStringRepresentation(root, ref representation);
            if (representation.Length > 1)
            {
                representation = representation.Substring(0, representation.Length - 2);
            }
            representation += "}";
            return representation;
        }
 
        public void Print() => Console.Write(GetStringRepresentation());
 
        public void Println() => Console.WriteLine(GetStringRepresentation());
 
        public AVLTreeNode<T> Find(T x) => Find(root, x);
    }
}

using System;
 
class A()
{
}
 
class MainClass
{
  public static ref A Method()
  {
    A x = new A();
    return ref x;
  }
  public static void Main (string[] args)
  {
    ref A x = ref Method();
  }
}