Summary of various methods of binary tree traversal

public class TreeNode
{
    public TreeNode left;
    public TreeNode right;
    public int value;
}
public class SearchTest
{    
    //前序遍历递归方式
    private void preOrder1(TreeNode root, List<int> dataList)
    {
        if (root != null)
        {
            dataList.Add(root.value);
            preOrder1(root.left, dataList);
            preOrder1(root.right, dataList);
        }
    }
    //前序遍历非递归实现
    private List<int> preOrder2(TreeNode root)
    {
        if (root == null)
            return null;
        List<int> dataList = new List<int>();
        Stack<TreeNode> stackList = new Stack<TreeNode>();
        TreeNode node = root;

        while (node != null || stackList.Count != 0)
        {
            if (node != null)
            {
                dataList.Add(node.value);
                stackList.Push(node);
                node = node.left;
            }
            else
            {
                node = stackList.Pop();
                node = node.right;
            }
        }
        return dataList;
    }
    //前序遍历第二种非递归方式
    private List<int> preOrder3(TreeNode root)
    {
        if (root == null)
            return null;
        List<int> dataList = new List<int>();
        Stack<TreeNode> stackList = new Stack<TreeNode>();
        TreeNode node = root;
        stackList.Push(node);

        while (stackList.Count != 0)
        {
            node = stackList.Pop();
            dataList.Add(node.value);

            if (node.right != null)
                stackList.Push(node.right);

            if (node.left != null)
                stackList.Push(node.left);
        }
        return dataList;
    }
    //中序遍历递归方式
    private void MidOrder1(TreeNode root, List<int> dataList)
    {
        if (root != null)
        {
            preOrder1(root.left, dataList);
            dataList.Add(root.value);
            preOrder1(root.right, dataList);
        }
    }
    //中序遍历非递归方式
    private List<int> MidOrder1(TreeNode root)
    {
        if (root == null)
            return null;
        List<int> dataList = new List<int>();
        Stack<TreeNode> stackList = new Stack<TreeNode>();
        TreeNode node = root;

        while (node != null || stackList.Count != 0)
        {
            if (node != null)
            {
                stackList.Push(node);
                node = node.left;
            }
            else
            {
                node = stackList.Pop();
                dataList.Add(node.value);
                node = node.right;
            }
        }
        return dataList;
    }

    //后序遍历递归
    private void PostOrder1(TreeNode root, List<int> dataList)
    {
        if (root != null)
        {
            preOrder1(root.left, dataList);
            preOrder1(root.right, dataList);
            dataList.Add(root.value);
        }
    }

    //后序遍历非递归实现
    private List<int> PostOrder2(TreeNode root)
    {
        if (root == null)
            return null;
        TreeNode pre = null;
        TreeNode cur = root;
        List<int> dataList = new List<int>();
        Stack<TreeNode> stackList = new Stack<TreeNode>();
        stackList.Push(cur);

        while (stackList.Count != 0)
        {
            cur = stackList.Peek();

            if (cur != null)
            {
                if (cur.left == null && cur.right == null
                    || (pre != null && (pre == cur.left || pre == cur.right)))
                {
                    cur = stackList.Pop();
                    dataList.Add(cur.value);
                    pre = cur;
                }
                else
                {
                    if (cur.right != null)
                        stackList.Push(cur.right);
                    if (cur.left != null)
                        stackList.Push(cur.left);
                }
            }
        }
        return dataList;
    }

    public class PNode
    {
        public TreeNode node;
        public bool isFirst;
        public PNode(TreeNode _node, bool _isFirst)
        {
            node = _node;
            isFirst = _isFirst;
        }
    }
    //后序遍历非递归实现
    private List<int> PostOrder3(TreeNode root)
    {
        if (root == null)
            return null;
        List<int> dataList = new List<int>();
        Stack<PNode> stackList = new Stack<PNode>();
        TreeNode node = root;

        while (node != null || stackList.Count != 0)
        {
            //深度遍历左子树
            while (node != null)
            {
                PNode pNode = new PNode(node, true);
                stackList.Push(pNode);
                node = node.left;
            }

            if (stackList.Count != 0)
            {
                PNode pNode = stackList.Pop();
                node = pNode.node;
                if (pNode.isFirst)
                {
                    pNode.isFirst = false;
                    stackList.Push(pNode);
                    node = node.right;
                }
                else
                {
                    dataList.Add(node.value);
                    node = null;
                }
            }
        }
        return dataList;
    }

    //层次遍历
    private List<int> Search(TreeNode root)
    {
        if (root == null)
            return null;
        List<int> dataList = new List<int>();
        TreeNode node = root;
        Queue<TreeNode> queueList = new Queue<TreeNode>();

        queueList.Enqueue(node);

        while (queueList.Count != 0)
        {
            node = queueList.Dequeue();
            dataList.Add(node.value);
            if (node.left != null)
            {
                queueList.Enqueue(node.left);
            }
            if (node.right != null)
            {
                queueList.Enqueue(node.right);
            }
        }
        return dataList;
    }
    //深度遍历即 前序遍历
}