二叉树

namespace Arbor
{
    /// <summary>
    /// LEFT左子树，RIGHT右子树
    /// </summary>
    enum Position { LEFT, RIGHT };
    /// <summary>
    /// LINK指向孩子，THREAD指向后继
    /// </summary>
    enum Tag { LINK, THREAD };
    /// <summary>
    /// 二叉树节点的抽象定义
    /// </summary>
    interface IBinNode
    {
        bool isLeaf();
        object Element { get; set; }
        IBinNode Left { get; set; }
        IBinNode Right { get; set; }
    }

    /// <summary>
    /// 遍历，线索化等操作的接口
    /// </summary>
    interface ITravelBinTree
    {
        void PreOrderTravel();
        void InOrderTravel();
        void RevOrderTravel();
        void Print(IBinNode t);
    }
    interface IInsertBinTree
    {
        void Insert(IBinNode node, Position pos);
    }
    /// <summary>
    /// Normal actualize of bintree
    /// </summary>
    class BinNodePtr : IBinNode
    {
        protected object element;
        protected IBinNode lchild;
        protected IBinNode rchild;
        public BinNodePtr(object e, IBinNode left, IBinNode right)
        {
            element = e;
            lchild = left;
            rchild = right;
        }
        public BinNodePtr(object e)
        {
            element = e;
            lchild = rchild = null;
        }
        public BinNodePtr()
        {
            element = null;
            lchild = rchild = null;
        }
        public bool isLeaf()
        {
            if (lchild == null && rchild == null)
                return true;
            return false;
        }
        public object Element
        {
            get { return element; }
            set { element = value; }
        }
        public IBinNode Left
        {
            get
            {
                return lchild;
            }
            set
            {
                lchild = value;
            }
        }
        public IBinNode Right
        {
            get
            {
                return rchild;
            }
            set
            {
                rchild = value;
            }
        }
    }
    class BinNodeLine : BinNodePtr, IBinNode
    {
        private Tag ltag, rtag;
        public BinNodeLine(object e, IBinNode left, IBinNode right)
            : base(e, left, right)
        { ltag = rtag = Tag.LINK; }
        public BinNodeLine(object e)
            : base(e)
        { ltag = rtag = Tag.LINK; }
        public Tag LTag
        {
            get { return ltag; }
            set { ltag = value; }
        }
        public Tag RTag
        {
            get { return rtag; }
            set { rtag = value; }
        }
    }
    class TravelBinTree : ITravelBinTree, IInsertBinTree
    {
        const int INIT_TREE_SIZE = 20;
        private IBinNode tree;
        private BinNodeLine head; //线索化后的头指针
        private IBinNode prenode; //指向最近访问过的前驱节点
        public TravelBinTree()
        {
            tree = new BinNodePtr();
        }
        public TravelBinTree(IBinNode INode)
        {
            tree = INode;
        }
        /// <summary>
        /// 先序遍历树,用非递归算法实现
        /// </summary>
        /// <remarks>非递归实现</remarks>
        public void PreOrderTravel()
        {
            IBinNode temptree;
            Stack stk = new Stack(INIT_TREE_SIZE);
            if (tree == null)
                throw (new InvalidOperationException("访问的树为空"));
            temptree = tree;
            stk.Push(tree);
            while (stk.Count != 0)
            {
                while (temptree != null)
                {
                    Print(temptree);
                    stk.Push(temptree.Left);
                    temptree = temptree.Left;
                } 
                stk.Pop(); // 空指针退栈
                if (stk.Count != 0)
                {
                    temptree = (IBinNode)stk.Pop();
                    stk.Push(temptree.Right);
                    temptree = temptree.Right;
                }
            }
        }
        public void InOrderTravel()
        {
            InOrderTravel(tree);
        }
        private void InOrderTravel(IBinNode t)
        {
            if (t == null) return;
            InOrderTravel(t.Left);
            Print(t);
            InOrderTravel(t.Right);
        }
        public void RevOrderTravel()
        {
            RevOrderTravel(tree);
        }
        private void RevOrderTravel(IBinNode t)
        {
            if (t == null) return;
            RevOrderTravel(t.Left);
            RevOrderTravel(t.Right);
            Print(t);
        }
        public void Print(IBinNode t)
        {
            Console.Write(t.Element + ",");
        }
        public void Insert(IBinNode node, Position pos)
        {
            if (node == null)
                throw (new InvalidOperationException("不能将空节点插入树"));
            switch (pos)
            {
                case Position.LEFT: tree.Left = node; break;
                case Position.RIGHT: tree.Right = node; break;
            }
        }
        /// <summary>
        /// 按照先序遍历顺序遍历树
        /// </summary>
        public void TreeBuilder()
        {
            Stack stk = new Stack(INIT_TREE_SIZE);
            stk.Push(tree);
            Position pos;
            string para;
            pos = Position.LEFT;
            IBinNode baby, temp;
            while (true)
            {
                para = Console.ReadLine();
                if (para == "")
                {
                    if (pos == Position.RIGHT)
                    {
                        stk.Pop();
                        while (stk.Count != 0 && ((IBinNode)stk.Peek()).Right != null)
                            stk.Pop();
                        if (stk.Count == 0) break;
                    }
                    else
                        pos = Position.RIGHT;
                }
                else
                {
                    // if (tree.GetType().Equals(baby) == true)
                    baby = new BinNodePtr(para);
                    temp = (IBinNode)stk.Peek();
                    if (pos == Position.LEFT)
                        temp.Left = baby;
                    else
                        temp.Right = baby;
                    pos = Position.LEFT;
                    stk.Push(baby);
                }
            }

        }
        /// <summary>
        /// 中序线索化
        /// </summary>
        public void InOrderThreading()
        {
            head = new BinNodeLine("");
            head.RTag = Tag.THREAD;
            head.Right = head;
            if (tree == null) head.Left = head;
            else
            {
                head.Left = tree; prenode = head;

            }
        }
        /// <summary>
        /// 中序线索化的递归实现
        /// </summary>
        /// <param name="t"></param>
        private void InThreading(IBinNode t)
        {
            if (t == null)
                return;
            else
            {
                InThreading(t.Left);
            }
        }
    }
}