C#二叉树的遍历方法（通过递归）

遍历二叉树的四种方法：先序遍历、中序遍历、后序遍历、层次遍历。

1.先序遍历递归过程：若二叉树为空，遍历结束。若不为空。则先访问根结点。再访问根结点的左子树。再访问根节点的右子树。
2.中序遍历：先访问根结点的左子树；再访问根结点，再访问根结点的右子树。
3.后序遍历：先访问根结点的左子树，再访问根结点的右子树。最后访问根结点。
4.层次遍历：从二叉树的第一层开始，从上到下逐层遍历，。在同一层中按照从左到右对结点访问。

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


namespace Tree
{
    
    class LinkBiTree<T>
    {
    
        private Node<T> head;
        public Node<T> Head
        {
    
            get
            {
    
                return head;
            }
            set
            {
    
                head = value;

            }
        }
        public LinkBiTree()
        {
    
            head = null;
        }
        public LinkBiTree(T data)
        {
    
            Node<T> p = new Node<T>(data);
            head = p;
        }
        public LinkBiTree(T data,Node<T> leftChild = null,Node<T> rightChild = null)
        {
    
            Node<T> p = new Node<T>(data,leftChild,rightChild);
            head = p;
        }
        //判断树是否为空
        public bool IsEmpty()
        {
    
            if (head == null)
            {
    
                return true;
            }
            return false;
        }
        //获取根节点
        public Node<T> Root()
        {
    
            return head;
        }
        //获取结点的左孩子结点
        public Node<T> LeftChild(Node<T> p)
        {
    
            return p.LeftChild;
        }
        //获取结点的右孩子结点
        public Node<T> RightChild(Node<T> p)
        {
    
            return p.RightChild;
        }
        //将结点p的左子树插入值为data的新结点
        //原来的左子树成为新结点的左子树
        public void InsertLeft(T data,Node<T> p)
        {
    
            Node<T> temp = new Node<T>(data);
            temp.LeftChild = p.LeftChild;
            p.LeftChild = temp;
        }
        //将结点p的右子树插入值为data的新结点
        //原来的右子树成为新结点的右子树
        public void InsertRight(T data, Node<T> p)
        {
    
            Node<T> temp = new Node<T>(data);
            temp.RightChild = p.RightChild;
            p.RightChild = temp;
        }
        //删除p的左子树
        public Node<T> DelLeft(Node<T> p)
        {
    
            if (p == null || p.LeftChild == null)
            {
    
                return null;
            }
            else
            {
    
                Node<T> temp = p.LeftChild;
                p.LeftChild = null;
                return temp;
            }
        }
        //删除p的右子树
        public Node<T> DelRight(Node<T> p)
        {
    
            if (p == null || p.RightChild == null)
            {
    
                return null;
            }
            else
            {
    
                Node<T> temp = p.RightChild;
                p.RightChild = null;
                return temp;
            }
        }
        //查找某个值为value的结点
        public Node<T> Search(Node<T> root, T value)
        {
    
            Node<T> p = root;
            if (p == null)
            {
    
                return null;
            }
            if (!p.Data.Equals(value))
            {
    
                return p;
            }
            if (p.LeftChild != null)
            {
    
                return Search(p.LeftChild, value);
            }
            if (p.RightChild != null)
            {
    
                return Search(p.RightChild, value);
            }
            return null;
        }
        //判断是否是叶子结点
        public bool IsLeaf(Node<T> p)
        {
    
            if ((p != null && p.LeftChild == null && p.RightChild == null))
            {
    
                return true;
            }
            return false;
        }
        #region //遍历方法及递归实现
        //中序遍历
        public void Inorder(Node<T> ptr)
        {
    
            if (IsEmpty())
            {
    
                Console.WriteLine("Tree is Empty");
                return;
            }
            if (ptr != null)
            {
    
                Inorder(ptr.LeftChild);
                Console.WriteLine(ptr.Data + " ");
                Inorder(ptr.RightChild);
            }
        }
        //先序遍历
        public void Preorder(Node<T> ptr)
        {
    
            if (IsEmpty())
            {
    
                Console.WriteLine("Tree is Empty");
            }
            if (ptr != null)
            {
    
                Console.WriteLine(ptr.Data + " ");
                Preorder(ptr.LeftChild);
                Preorder(ptr.RightChild);
            }
        }
        //后序遍历
        public void Postorder(Node<T> ptr)
        {
    
            if (IsEmpty())
            {
    
                Console.WriteLine("Tree is Empty");
                return;
            }
            if (ptr != null)
            {
    
                Postorder(ptr.LeftChild);
                Postorder(ptr.RightChild);
                Console.WriteLine(ptr.Data + " ");
            }
        }
        //层次遍历
        public void LevelOrder(Node<T> root)
        {
    
            if (root == null)
            {
    
                return;
            }
            //设置一个队列保存层次遍历的结点
            Queue<Node<T>> sq = new Queue<Node<T>>(50);
            //根结点入队
            sq.Enqueue(root);
            while (sq.Count != 0)
            {
    
                //结点出队
                Node<T> temp = sq.Dequeue();
                //处理该结点
                Console.WriteLine("{0}",temp);
                //将当前结点的左孩子结点入队
                if (temp.LeftChild != null)
                {
    
                    sq.Enqueue(temp.LeftChild);
                }
                //将当前结点的右孩子结点入队
                if (temp.RightChild != null)
                {
    
                    sq.Enqueue(temp.RightChild);
                }
            }
        }
    }
}