C#使用自定义的泛型节点类实现二叉树类_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)
                    {
                        if (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);
            }
        }
    }
}

运行结果：