C#使用自定义的泛型节点类实现二叉树类_开发_开发者

一、涉及到的知识点

1.Comparer<T>.Default 属性

返回由泛型参数指定的类型的默认排序顺序比较器。

public static System.Collections.Generic.Comparer<T> Default { get; }

属性值

Comparer<T>

继承 Comparer<T> 并作为 T 类型的排序顺序比较器的对象。

Comparer<T>.Default 属性是 C# 中 System.Collections.Generic命名空间下的一个属性。它返回一个编程客栈 Comparer<T> 对象的默认实例，该编程客栈对象可以对泛型集合中的对象进行比较。默认情况下，这个比较器根据对象的自然顺序进行比较，即通过调用对象的 CompareTo 方法进行比较。

// Comparer<T>.Default 属性
 
namespace _135_3
{
    public 编程class Program
    {
        public static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            List<int> numbers = [3, 1, 4, 2];
 
            // 使用默认比较器对集合进行排序
            numbers.Sort(Comparer<int>.Default);
 
            Console.WriteLine(string.Join(", ", numbers));
        }
    }
}
//运行结果：
/*
1, 2, 3, 4
 */

在这个例子中创建了一个包含整数的列表。然后，使用 Comparer<int>.Default 属性提供的默认比较器对列表进行排序。最后，输出排序后的列表，可以看到数字已经按照升序排列。

2.实现二叉树类BinaryTree<T>步骤

（1）先设计一个泛型节点类

public class Node<T>(T value)
{
    public T Data { get; set; } = value;
    public Node<T>? Left { get; set; } = null;
    public Node<T>? Right { get; set; } = null;
}

（2）再设计一个泛型的二叉树类

public class BinaryTree<T>
{
    public Node<T>? Root { get; private set; }
 
    public void AddNode(T value)
    {
        Node<T> newNode = new(value);
        if (Root == null)
        {
            Root = newNode;
        }
        else
        {
            Node<T> current = Root;
            while (true)
            {
                if (Comparer<T>.Default.Compare(value, current.Data) < 0)
                {
                    if (current.Left == null)
                    {
                        current.Left = newNode;
                        break;
                    }
                    current = current.Left;
                }
                else
                {
                    if (current.Right == null)
                    {
                        current.Right = newNode;
                        break;
                    }
                    current = current.Right;
                }
            }
        }
    }
}

（3）最后设计Main方法

定义一个二叉树类的对象，引用类中的方法。

BinaryTree<int> tree = new();

二、使用泛型节点类 Node<T>实现二叉树类BinaryTree<T>

// 使用泛型节点类 Node<T>设计实现二叉树类
namespace _135_1
{
    public class Node<T>(T value)
    {
        public T Data { get; set; } = value;
        public Node<T>? Left { get; set; } = null;
        public Node<T>? Right { get; set; } = null;
    }
 
    public class BinaryTree<T>
    {
        public Node<T>? Root { get; private set; }
 
        public void AddNode(T value)
        {
            Node<T> newNode = new(value);
            if (Root == null)
            {
                Root = newNode;
            }
            else
            {
                Node<T> current = Root;
                while (true)
                {
                    if (Comparer<T>.Default.Compare(value, current.Data) < 0)
                    {
                        i编程客栈f (current.Left == null)
                        {
                            current.Left = newNode;
                            break;
                        }
                        current = current.Left;
                    }
                    else
                    {
                        if (current.Right == null)
   编程客栈                     {
                            current.Right = newNode;
                            break;
                        }
                        current = current.Right;
                    }
                }
            }
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            BinaryTree<int> tree = new();
            tree.AddNode(5);
            tree.AddNode(3);
            tree.AddNode(8);
            tree.AddNode(1);
            tree.AddNode(4);
            tree.AddNode(7);
 
            Console.WriteLine("中序遍历：");
            PrintInOrder(tree.Root!);
 
            Console.WriteLine("前序遍历：");
            PrintPreOrder(tree.Root!);
 
            Console.WriteLine("后序遍历：");
            PrintPostOrder(tree.Root!);
 
            Console.ReadKey();
        }
 
        static void PrintInOrder(Node<int> node)
        {
            if (node != null)
            {
                PrintInOrder(node.Left!);
                Console.WriteLine(node.Data);
                PrintInOrder(node.Right!);
            }
        }
 
        static void PrintPreOrder(Node<int> node)
        {
            if (node != null)
            {
                Console.WriteLine(node.Data);
                PrintPreOrder(node.Left!);
                PrintPreOrder(node.Right!);
            }
        }
 
        static void PrintPostOrder(Node<int> node)
        {
            if (node != null)
            {
                PrintPostOrder(node.Left!);
                PrintPostOrder(node.Right!);
                Console.WriteLine(node.Data);
            }
        }
    }
}

运行结果：