非递归实现二叉树的先、中、后序排列

NC45 实现二叉树先序，中序和后序遍历

描述
给定一棵二叉树，分别按照二叉树先序，中序和后序打印所有的节点。

思路：
利用进栈和出栈的顺序巧妙实现

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型二维数组
     */
    
        ArrayList<Integer> front = new ArrayList<>();
        ArrayList<Integer> mid = new ArrayList<>();
        ArrayList<Integer> back = new ArrayList<>();
    
    public int[][] threeOrders (TreeNode root) {
        PreorderTraversal(root);
        InorderTraversal(root);
        PostorderTraversal(root);
        
        int[][] res = new int[3][front.size()];
        for(int j = 0; j < front.size(); ++j)
            res[0][j] = front.get(j);
        for(int j = 0; j < front.size(); ++j)
            res[1][j] = mid.get(j);
        for(int j = 0; j < front.size(); ++j)
            res[2][j] = back.get(j);
        return res;
    }
    
     //前序遍历
    public void PreorderTraversal(TreeNode root){
        if(root == null)
            return;
        //先序遍历
        Stack<TreeNode> s1=new Stack<>();
        TreeNode p1=root;
        s1.push(p1);//根节点先入栈
        while(!s1.isEmpty()){//当栈不为空，入栈顺序为中右左
            TreeNode cur=s1.pop();
            //System.out.print(p1.val);
            front.add(cur.val);
            if(cur.right!=null){//右孩子先入栈
                s1.push(cur.right);
            }
            if(cur.left!=null){//左孩子入栈
                s1.push(cur.left);
            }
        }
    }
        //中序遍历
    public void InorderTraversal(TreeNode root){
        if(root == null)
            return;
         //中序遍历
        Stack<TreeNode> s1=new Stack<>();
        s1.push(root);
        TreeNode cur=root;
        while(cur!=null || !s1.isEmpty()){
            if(cur!=null){//第一阶段将根的左子树全部入栈
                s1.push(cur);
                cur=cur.left;
            }else{//第一阶段结束，开始弹出栈中元素，判断有无右子树，重复阶段一
                cur=s1.pop();
                mid.add(cur.val);
                cur=cur.right;
            }
        }
    }
        
         //后序遍历
    public void PostorderTraversal(TreeNode root){
        if(root == null)
            return;
        //后序遍历
        Stack<TreeNode> s1=new Stack<>();
        Stack<TreeNode> s2=new Stack<>();
        s1.push(root);//头节点先入栈
        while(!s1.isEmpty()){//和先序不同的是：入栈顺序为中左右
            TreeNode cur2=s1.pop();
           // back.add(cur2.val);
            s2.push(cur2);
            if(cur2.left!=null){//左孩子入栈
                s1.push(cur2.left);
            }
            if(cur2.right!=null){//右孩子先入栈
                s1.push(cur2.right);
            }
            
        }
        while(!s2.isEmpty()){
            back.add(s2.pop().val);
        }
    }

}

总结
想好入栈顺序
先序（中左右）：入栈顺序：中（再弹出），右左入栈，再弹出
中序（左中右）：先将最左边结点入栈，结束后再弹出并将cur等于右节点（有则将其入栈，无则继续弹出）
后序（左右中）：入栈顺序：中（再弹出入栈到s2），左右入栈，再弹出，往复

中序和后序稍微麻烦一下，后序需要两个栈，栈2用于收集最后结果