Код бинарного дерева, добавить класс дерева методом, определяющим его глубину и ширин

using System;
using System.Collections.Generic;
using System.Linq;
 
// Шаблонный класс узла двоичного дерева
public class BinaryTreeNode<T>
{
    public T Data { get; set; } // Значение узла
    public BinaryTreeNode<T> Left { get; set; } // Левое поддерево
    public BinaryTreeNode<T> Right { get; set; } // Правое поддерево
 
    // Конструктор для создания узла с заданным значением
    public BinaryTreeNode(T data)
    {
        Data = data;
        Left = null;
        Right = null;
    }
}
 
// Шаблонный класс двоичного дерева
public class BinaryTree<T>
{
    public BinaryTreeNode<T> Root { get; private set; } // Корень дерева
 
    // Конструктор для создания пустого дерева
    public BinaryTree()
    {
        Root = null;
    }
 
    // Метод для определения глубины дерева
    public int GetDepth()
    {
        return GetDepth(Root);
    }
 
    // Рекурсивный метод для определения глубины дерева
    private int GetDepth(BinaryTreeNode<T> node)
    {
        if (node == null)
            return 0;
 
        int leftDepth = GetDepth(node.Left); // Глубина левого поддерева
        int rightDepth = GetDepth(node.Right); // Глубина правого поддерева
 
        // Глубина текущего узла равна максимуму из глубин поддеревьев, плюс 1
        return Math.Max(leftDepth, rightDepth) + 1;
    }
 
    // Метод для определения ширины дерева
    public int GetWidth()
    {
        int maxWidth = 0;
        for (int level = 1; level <= GetDepth(); level++)
        {
            int width = GetWidth(Root, level); // Ширина на текущем уровне
            if (width > maxWidth)
                maxWidth = width; // Обновляем максимальную ширину
        }
        return maxWidth;
    }
 
    // Рекурсивный метод для определения ширины на заданном уровне
    private int GetWidth(BinaryTreeNode<T> node, int level)
    {
        if (node == null)
            return 0;
        if (level == 1)
            return 1; // На уровне 1 ширина всегда равна 1
        else if (level > 1)
            // Рекурсивно считаем ширину на левом и правом поддеревьях и складываем
            return GetWidth(node.Left, level - 1) + GetWidth(node.Right, level - 1);
        return 0;
    }
 
    // Метод для вставки элемента в дерево
    public void Insert(T value)
    {
        Root = Insert(Root, value);
    }
 
    // Рекурсивный метод для вставки элемента в дерево
    private BinaryTreeNode<T> Insert(BinaryTreeNode<T> node, T value)
    {
        if (node == null)
        {
            return new BinaryTreeNode<T>(value);
        }
 
        if (Comparer<T>.Default.Compare(value, node.Data) < 0)
        {
            node.Left = Insert(node.Left, value); // Вставка в левое поддерево
        }
        else if (Comparer<T>.Default.Compare(value, node.Data) > 0)
        {
            node.Right = Insert(node.Right, value); // Вставка в правое поддерево
        }
 
        return node;
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        BinaryTree<int> tree = null; // Объявляем дерево
 
        int choice;
        do
        {
            Console.WriteLine("Меню:");
            Console.WriteLine("1. Создать дерево вручную");
            Console.WriteLine("2. Создать случайное дерево");
            Console.WriteLine("3. Определить глубину дерева");
            Console.WriteLine("4. Определить ширину дерева");
            Console.WriteLine("0. Выход");
            Console.Write("Выберите действие: ");
 
            if (int.TryParse(Console.ReadLine(), out choice))
            {
                switch (choice)
                {
                    case 1:
                        tree = CreateManualTree();
                        Console.WriteLine("Дерево создано вручную.");
                        break;
 
                    case 2:
                        tree = CreateRandomTree();
                        Console.WriteLine("Случайное дерево создано.");
                        PrintTree(tree.Root); // Выводим элементы дерева
                        break;
 
 
                    case 3:
                        if (tree == null)
                        {
                            Console.WriteLine("Сначала создайте дерево.");
                        }
                        else
                        {
                            Console.WriteLine("Глубина дерева: " + tree.GetDepth()); // Выводим глубину
                        }
                        break;
 
                    case 4:
                        if (tree == null)
                        {
                            Console.WriteLine("Сначала создайте дерево.");
                        }
                        else
                        {
                            Console.WriteLine("Ширина дерева: " + tree.GetWidth()); // Выводим ширину
                        }
                        break;
 
                    case 0:
                        Console.WriteLine("Выход.");
                        break;
 
                    default:
                        Console.WriteLine("Некорректный выбор.");
                        break;
                }
            }
            else
            {
                Console.WriteLine("Некорректный ввод.");
            }
        } while (choice != 0);
    }
 
    // Метод для создания дерева вручную
    static BinaryTree<int> CreateManualTree()
    {
        BinaryTree<int> tree = new BinaryTree<int>();
        Console.WriteLine("Введите элементы дерева через пробел:");
        int[] values = Console.ReadLine()
            .Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
            .Select(int.Parse)
            .ToArray();
        foreach (int value in values)
        {
            tree.Insert(value);
        }
        return tree;
    }
 
    // Метод для создания случайного дерева
    static BinaryTree<int> CreateRandomTree()
    {
        BinaryTree<int> tree = new BinaryTree<int>();
        Random rand = new Random();
        int numberOfNodes = rand.Next(5, 15); // Генерируем случайное количество узлов
        for (int i = 0; i < numberOfNodes; i++)
        {
            int value = rand.Next(1, 100); // Генерируем случайное значение
            tree.Insert(value); // Добавляем элемент в дерево
        }
        return tree;
    }
 
    // Метод для вывода элементов дерева (обход в порядке in-order)
    static void PrintTree(BinaryTreeNode<int> node)
    {
        if (node != null)
        {
            PrintTree(node.Left); // Рекурсивно обходим левое поддерево
            Console.Write( node.Data + " "); // Выводим значение узла
            PrintTree(node.Right); // Рекурсивно обходим правое поддерево
        }
    }
}