C#实现二叉树

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BinaryTree
{
    class Program
    {
        static void Main(string[] args)
        {
            Tree<int> myTree = new Tree<int>(5);
            for (int i = 0; i < 10; i++)
            {
                myTree.Insert(i);
            }
            //myTree.WideOrderTree();
            //myTree.PreOrderTree(myTree);
            //myTree.InOrderTree(myTree);
            myTree.PostOrderTree(myTree);
        }

        //定义二叉树
        public class Tree<T> where T : IComparable<T>
        {
            private T data;
            private Tree<T> leftTree;
            private Tree<T> rightTree;

            //属性
            public T Data
            {
                get
                {
                    return data;
                }
                set
                {
                    data = value;
                }
            }

            public Tree<T> LeftTree
            {
                get
                {
                    return leftTree;
                }
                set
                {
                    leftTree = value;
                }
            }

            public Tree<T> RightTree
            {
                get
                {
                    return rightTree;
                }
                set
                {
                    rightTree = value;
                }
            }

            //构造函数，定义二叉树根节点
            public Tree(T data)
            {
                this.data = data;
                leftTree = null;
                rightTree = null;
            }

            /// <summary>
            /// 向二叉树中插入一个新的结点
            /// 小于根节点插入左子树
            /// 大于根节点插入右子树
            /// </summary>
            public void Insert(T data)
            {
                T dataNow = Data;
                if (data.CompareTo(dataNow) < 0)
                {
                    if (LeftTree == null)
                    {
                        LeftTree = new Tree<T>(data);
                    }
                    else
                    {
                        LeftTree.Insert(data);
                    }
                }
                else
                {
                    if (RightTree == null)
                    {
                        RightTree = new Tree<T>(data);
                    }
                    else
                    {
                        RightTree.Insert(data);
                    }
                }
            }

            /// <summary>
            /// 前序遍历：中左右
            /// </summary>
            public void PreOrderTree(Tree<T> root)
            {
                if (root != null)
                {
                    Console.WriteLine(root.Data);
                    PreOrderTree(root.LeftTree);
                    PreOrderTree(root.RightTree);
                }
            }

            /// <summary>
            /// 中序遍历：左中右
            /// </summary>
            public void InOrderTree(Tree<T> root)
            {
                if (root != null)
                {
                    InOrderTree(root.LeftTree);
                    Console.WriteLine(root.Data);
                    InOrderTree(root.RightTree);
                }
            }

            /// <summary>
            /// 后序遍历：左右中
            /// </summary>
            public void PostOrderTree(Tree<T> root)
            {
                if (root != null)
                {
                    PostOrderTree(root.LeftTree);
                    PostOrderTree(root.RightTree);
                    Console.WriteLine(root.Data);
                }
            }

            /// <summary>
            /// 逐层遍历：
            /// 1. 从根节点开始，访问一个节点然后将其左右子树的根节点一次放入链表，然后删除该根节点。
            /// 2. 依次遍历链表中的元素，直到链表中元素数量为0。
            /// </summary>
            public void WideOrderTree()
            {
                List<Tree<T>> nodeList = new List<Tree<T>>();
                nodeList.Add(this);
                Tree<T> temp = null;
                while (nodeList.Count > 0)
                {
                    Console.WriteLine(nodeList[0].Data);
                    temp = nodeList[0];
                    nodeList.RemoveAt(0);
                    if (temp.LeftTree != null)
                    {
                        nodeList.Add(temp.LeftTree);
                    }
                    if (temp.RightTree != null)
                    {
                        nodeList.Add(temp.RightTree);
                    }
                }
            }
        }
    }
}