C#数据结构中的二叉树

class MyTree

    {
        public MyTree(char node)
        {
            Node = node;


        }
        public char Node;
        public MyTree lefttree;
        public MyTree righttree;

    }

 //递归的先序遍历
        private static void pre_view_recur(MyTree mt)
        { 
         if(mt!=null)
         {
             Console.Write(mt.Node);
             pre_view_recur(mt.lefttree);
             pre_view_recur(mt.righttree);
         }
        }


        //非递归的先序遍历
        private static void pre_view_none_recur(MyTree mt)
        { 
            //判断是否为空
            if(mt==null)
            {
                return;
            }
            //定义一个栈
            Stack<MyTree> mtStack = new Stack<MyTree>();
            //当二叉树还有元素并且栈不为空时
            while(mt!=null || mtStack.Any())
            {
                //如果二叉树不为空，说明可以向左遍历
                if (mt != null)
                {
                    Console.Write(mt.Node); 
                    mtStack.Push(mt); //将子树入栈
                    mt = mt.lefttree;//向左遍历
                }
                else //为空说明左边遍历完了，退回一步，将上一个节点赋给新的子树
                {
                    mt=mtStack.Pop();
                    mt = mt.righttree; //向右遍历
                }
            }
        }




        //递归方法处理：中序遍历
        private static void mdi_view_recur(MyTree mt)
        { 
          if(mt!=null)
          {
              mdi_view_recur(mt.lefttree);
              Console.Write(mt.Node);
              mdi_view_recur(mt.righttree);
          }
        }


        //非递归实现：中序遍历
        private static void mdi_view_none_recur(MyTree mt)
        { 
            if(mt==null)
            {
                return;
            }
            Stack<MyTree> mtStack = new Stack<MyTree>();


            while(mt!=null || mtStack.Any())
            {
                if (mt!= null)
                {
                    mtStack.Push(mt);
                    mt = mt.lefttree;
                }
                else
                {
                    mt=mtStack.Pop();
                    Console.Write(mt.Node);
                    mt = mt.righttree;
                }
              
            }
        }


        //递归实现后序遍历
        private static void last_view_recur(MyTree mt)
        { 
          if(mt!=null)
          {
              last_view_recur(mt.lefttree);
              last_view_recur(mt.righttree);
              Console.Write(mt.Node);
          }
        }

//非递归实现后序遍历

后序遍历可以看作是下面遍历的逆过程：即先遍历某个结点，然后遍历其右孩子，然后遍历其左孩子。这个过程逆过来就是后序遍历。

        private static void last_view_none_recur(MyTree mt)
        {
            //进栈顺序为根、右、左只有这样才能出栈变为左右中
            //当左右子树均没有，或者左子树已经访问完，再访问右子树，当左右子树都访问完时，在访问根
            MyTree preTree = null;//定义一个编辑位
            MyTree nowTree = null;//定义正在访问的节点
            Stack<MyTree> mtStack = new Stack<MyTree>();
            mtStack.Push(mt);
            while (mtStack.Any())
            {
                nowTree = mtStack.Peek();
                //如果当前左右子树为0，或者标记位不为空，并且是现在节点的左右子树
                if ((nowTree.lefttree == null && nowTree.righttree == null) ||
                    (preTree != null && (preTree == nowTree.lefttree || preTree == nowTree.righttree)))
                {
                    Console.Write(nowTree.Node);
                    preTree=mtStack.Pop();
                }
                else
                {
                    if (nowTree.righttree != null)
                    {
                        mtStack.Push(nowTree.righttree);
                    }
                    if (nowTree.lefttree != null)
                    {
                        mtStack.Push(nowTree.lefttree);
                    }
                }
            }
        }

 //层次遍历 利用队列实现,根节点进入队列中，然后输出，再左右进入，循环
        private static void cengci_view(MyTree mt)
        {
            Queue<MyTree> mtQueue = new Queue<MyTree>();
            mtQueue.Enqueue(mt);
            while(mtQueue.Any())
            {
                mt = mtQueue.Dequeue();
                if(mt!=null)
                {
                    Console.Write(mt.Node);
                }
                if(mt.lefttree!=null)
                {
                    mtQueue.Enqueue(mt.lefttree);
                }
                if(mt.righttree!=null)
                {
                    mtQueue.Enqueue(mt.righttree);
                }
            }
        }

实现过程：

  MyTree tree = new MyTree('A');
            tree.lefttree = new MyTree('B');
            tree.lefttree.lefttree = new MyTree('D');
            tree.lefttree.lefttree.lefttree = new MyTree('G');
            tree.lefttree.righttree = new MyTree('E');
            tree.lefttree.righttree.righttree = new MyTree('H');


            tree.righttree = new MyTree('C');
            tree.righttree.righttree = new MyTree('F');


            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write("前序遍历1:");
            pre_view_recur(tree);


            Console.WriteLine();
            Console.Write("前序遍历2:");
            pre_view_none_recur(tree);


            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.White;
            Console.Write("中序遍历1:");
            mdi_view_recur(tree);
            Console.WriteLine();
            Console.Write("中序遍历2:");
            mdi_view_none_recur(tree);


            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write("后序遍历1:");
            last_view_recur(tree);
            Console.WriteLine();
            Console.Write("后序遍历2:");
            last_view_none_recur(tree);


            // last_view_none_recur(tree);


            Console.WriteLine();
            Console.Write("层次遍历:");
            Console.BackgroundColor = ConsoleColor.Gray;
            cengci_view(tree);








            Console.Read();