Удаление вершины бинарного дерева

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
 
namespace BinTree
{
    /// <summary>
    // Программа позволяет построить бинарное дерево и выполнять операции над ним:
    //  - включения элемента в дерево в соответствии с его значением, 
    //  - поиск элемента, 
    //  - вывод на экран элементов, включённых в дерево, в порядке возрастания и убывания,
    //  - удаление элемента, 
    //  - подсчёт количества элементов.
    /// </summary>
    /// 
    public class BinTree
    {
        /// <summary>
        /// Корень бинарного дерева
        /// </summary>
        public BinTreeNode Root { get; private set; }
 
        /// <summary>
        /// Подсчёт количества элементов в дереве
        /// </summary>
        /// <returns></returns>
        public int Count
        {
            get
            {
                return CountRec(Root); // вызов рекурсивной функции подсчета вершин
            }
        }
 
        /// <summary>
        /// Подсчёт количества элементов в дереве через рекурсивный обход его элементов
        /// </summary>
        /// <returns></returns>
        int CountRec(BinTreeNode R)
        {
            if (R == null)
                return 0;
            else return CountRec(R.Left) + 1 + CountRec(R.Right);
        }
 
        /// <summary>
        /// Добавление элемента (узла) в дерево в соответствии с заданным порядком значений.
        /// Параметр - значение, записываемое в добавленный узел.
        /// </summary>
        public void AddNode(string value)
        {
            BinTreeNode R = Root;
            AddNewNode(ref R, value); // запускаем рекурсивный алгоритм вставки иновой вершины в дерево
            if (Root == null)
                Root = R;
            return;
        }
 
        /// <summary>
        /// Добавление нового узла со значением value в дерево с корнем R.
        /// Поиск места для вставки нового узла - рекурсивный.
        /// Ссылка на узел передаётся по ссылке, чтобы можно было установить связь
        /// созданного узла с его предком, левым или правым потомком которого 
        /// новый узел будет.
        /// Для первого созданного узла ссылка на него будет записана в корень дерева.
        /// </summary>
        static int i = 1;
        void AddNewNode(ref BinTreeNode R, string value)
        {
            if (R == null) // Нашли ли "свободное место"?
            { // Нерекурсивная ветвь - вставляем новый элемент в дерево:
                BinTreeNode NewNode = new BinTreeNode(); // создаём новый элемент
                NewNode.Info = value;// запоминаем в его информационном поле значение
                NewNode.count = i;
                NewNode.Left = null; // элемент - листовой, левого потомка нет
                NewNode.Right = null;// элемент - листовой, правого потомка нет
                R = NewNode; // возвращаем ссылку на созданный узел
                i++;
                return;
            }
            else
            { // Рекурсивная ветвь - продолжаем поиск "предка" для нового узла:
                int result = value.CompareTo(R.Info);
                if (result > 0)
                {   // Новое значение больше значения выбранного узла - новый узел будет в правом поддереве:
                    BinTreeNode FR = R.Right;
                    AddNewNode(ref FR, value);
                    R.Right = FR;
                }
                else
                {
                    if (result < 0)
                    {   // Новое значение меньше значения выбранного узла - новый узел будет в левом поддереве:
                        BinTreeNode FR = R.Left;
                        AddNewNode(ref FR, value);
                        R.Left = FR;
                    }
                    else
                    {
                        Console.WriteLine("Данное значение уже присутсвует в дереве под номером {0}", R.count);
                    }
                }
                return;
            }
        }
 
        /// <summary>
        /// Удаление всех узлов дерева рекурсивным обходом.
        /// </summary>
        public void ClearTree()
        {
            BinTreeNode R = Root;
            ClearAllNodes(R); // запускаем рекурсивный алгоритм обхода вершин
            Root = null; // стираем ссылку на корень
            return;
        }
 
        /// <summary>
        /// Обход вершин дерева для его уичтожения.
        /// </summary>
        void ClearAllNodes(BinTreeNode R)
        {
            if (R == null) // Вершины нет - удалять нечего
            { // Нерекурсивная ветвь - возврат:
                return;
            }
            else
            { // Рекурсивная ветвь - продолжаем поиск обход:
                ClearAllNodes(R.Left); // обходим потомка - левое поддерево
                R.Left = null; // стираем ссылку на левого потомка
                ClearAllNodes(R.Right); // обходим потомка - правое поддерево
                R.Right = null; // стираем ссылку на правого потомка
                return;
            }
        }
 
 
        /// <summary>
        /// Формирование строки, содержащей все значения, записанные в бинарное дерево,
        /// для их вывода на экран.
        /// Значения выводятся в порядке возрастания.
        /// Рекурсивный вариант.
        /// </summary>
        /// <returns></returns>
        /// <summary>
        /// Рекурсивный обход списка и формирование строки, содержащей значения.
        /// </summary>
        /// <returns></returns>
        public void Min(BinTreeNode R)
        {
            string stringBuilder;
 
            if (R != null) // Нерекурсивная ветвь - элементов (больше) нет.
            { // Рекурсивная ветвь:
                Min(R.Left); // вывод значений из левого потомка
                stringBuilder = R.count + " " + R.Info;// вывод значения из текущего узла дерева
                Console.WriteLine(stringBuilder);
                Min(R.Right);// вывод значений из правого потомка
                // Пополнили строку - возвращаем:
 
            }
 
        }
 
        /// <summary>
        /// Формирование строки, содержащей все значения, записанные в бинарное дерево,
        /// для их вывода на экран.
        /// Значения выводятся в порядке убывания.
        /// Рекурсивный вариант.
        /// </summary>
        /// <returns></returns>
        public string ToStringFromMax()
        {
            StringBuilder stringBuilder = new StringBuilder();
 
            // Запуск рекурсивной функции добавления значений в строку.
            // Рекурсией управляет параметр - ссылка на выбранный узел дерева.
            // Прямой ход рекурсии начинается с корневого узла.
            stringBuilder.AppendFormat("{0},", AddToStringValMax(Root));
            return stringBuilder.ToString();
        }
 
        /// <summary>
        /// Рекурсивный обход списка и формирование строки, содержащей значения.
        /// </summary>
        /// <returns></returns>
        public string AddToStringValMax(BinTreeNode R)
        {
            String stringBuilder;
 
            if (R == null) // Нерекурсивная ветвь - элементов (больше) нет.
            { // Прямой ход рекурсии завершён:
                stringBuilder = ""; // проинициализировали и 
                return stringBuilder.ToString(); // вернули строку - она может пополниться
            }
            else
            { // Рекурсивная ветвь:
                stringBuilder = " " + AddToStringValMax(R.Right) // вывод значений из правого потомка
                                + " " + R.Info // вывод значения из текущего узла дерева
                                + " " + AddToStringValMax(R.Left); // вывод значений из левого потомка
                // Пополнили строку - возвращаем:
                return stringBuilder.ToString();
            }
 
        }
 
    }
    public class BinTreeNode
    {
        public BinTreeNode()
        {
        }
 
        public BinTreeNode(string value)
        {
            Info = value;
        }
        public int count { get; set; }
        public string Info { get; set; }
        public BinTreeNode Left { get; set; }
        public BinTreeNode Right { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            BinTree binTree = new BinTree(); // инициализация дерева
            string command;
            // Вывод строки-подсказки со списком команд - операций над списком:
            Console.WriteLine("Введите print_min|print_max|add @value@|clear|count|delete @value@|end");
 
            while (true) // Основной цикл - выпонение операций над списком
            {
                Console.Write(">");
                command = Console.ReadLine(); // чтение команды с клавиатуры и
                // и сопоставление её со списком заданных в программе команд:
                Match match = Regex.Match(command, @"(?<command>print_min|print_max|add|clear|count|delete|end)\s*(?<arguments>\w*)");
 
                // Выбор и выполнение заданной команды:
                if (match.Groups["command"].Success)
                {
                    switch (match.Groups["command"].Value)
                    {
                        case "print_min":
 
                            binTree.Min(binTree.Root);
                            break;
                        case "print_max":
                            Console.WriteLine(binTree.ToStringFromMax());
                            break;
                        case "add":
                            string int_val = Convert.ToString(match.Groups["arguments"].Value);
                            binTree.AddNode(int_val);
                            break;
                        case "clear":
                            binTree.ClearTree();
                            break;
                        case "count":
                            Console.WriteLine(binTree.Count);
                            break;
                        case "delete":
                            ///binTree.Delete(match.Groups["arguments"].Value);
                            break;
                        case "end":
                            return;
                    }
                }
                else
                    Console.WriteLine("Неверная команда");
            };
 
        }
    }
}