重学算法（1）--遍历二叉树

public class Tree<T> where T : IComparable<T>
    {
        /// <summary>
        /// 定义树
        /// </summary>
        private T data;
        private Tree<T> left;
        private Tree<T> right;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="nodeValue">二叉树根节点</param>
        public Tree(T nodeValue)
        {
            this.data = nodeValue;
            this.left = null;
            this.right = null;
        }

        /// <summary>
        /// 数据节点属性
        /// </summary>
        public T NodeData
        {
            get { return this.data; }
            set { this.data = value; }
        }

        public Tree<T> leftTree
        {
            get { return this.left; }
            set { this.left = value; }
        }

        public Tree<T> rightTree
        {
            get { return this.right; }
            set { this.right = value; }
        }

        /// <summary>
        /// 插入节点 小于该节点的放左侧，大于该节点的放右侧
        /// </summary>
        /// <param name="newItem"></param>
        public void Insert(T newItem)
        {
            T currentNodeValue = this.NodeData;
            if (currentNodeValue.CompareTo(newItem) > 0)
            {
                if (this.leftTree == null)
                {
                    this.leftTree = new Tree<T>(newItem);
                }
                else
                {
                    this.leftTree.Insert(newItem);
                }
            }
            else
            {
                if (this.rightTree == null)
                {
                    this.rightTree = new Tree<T>(newItem);
                }
                else
                {
                    this.rightTree.Insert(newItem);
                }
            }
        }

        /// <summary>
        /// 先序遍历 根 左 右
        /// </summary>
        /// <param name="root"></param>
        public void PreOrderTree(Tree<T> root)
        {
            if (root != null)
            {
                Console.Write(root.NodeData);
                PreOrderTree(root.leftTree);
                PreOrderTree(root.rightTree);
            }
        }

        /// <summary>
        /// 中序遍历 左 根 右
        /// </summary>
        /// <param name="root"></param>
        public void InOrderTree(Tree<T> root)
        {
            if (root != null)
            {
                InOrderTree(root.leftTree);
                Console.Write(root.NodeData);
                InOrderTree(root.rightTree);
            }
        }

        /// <summary>
        /// 后序遍历 左 右 根
        /// </summary>
        /// <param name="root"></param>
        public void PostOrderTree(Tree<T> root)
        {
            if (root != null)
            {
                PostOrderTree(root.leftTree);
                PostOrderTree(root.rightTree);
                Console.Write(root.NodeData);
            }
        }

        /// <summary>
        /// 逐层遍历：从根节点开始，访问一个节点然后将左右子树的根节点依次放入链表中，删除该节点
        /// 遍历到链表中没有数据为止
        /// </summary>
        public void WideOrderTree()
        {
            List<Tree<T>> nodeList = new List<Tree<T>>();
            nodeList.Add(this);
            Tree<T> temp = null;
            while (nodeList.Count > 0)
            {
                Console.Write(nodeList[0].NodeData);
                temp = nodeList[0];
                nodeList.Remove(nodeList[0]);
                if (temp.leftTree != null)
                {
                    nodeList.Add(temp.leftTree);
                }
                if (temp.rightTree != null)
                {
                    nodeList.Add(temp.rightTree);
                }
            }
            Console.WriteLine();
        }

    }

这是第二次让人讲二叉树了，一定不可以忘记！