二叉树迭代遍历法

1.迭代先序遍历

利用栈实现前序遍历的迭代

1. 将root压入（push）栈
2. 当栈不为空时进行迭代
   （1） cur为出栈元素（出栈的首先是根节点，再是左节点，最后是右节点）
   （2）当cur有右子树时先将右子树入栈，再将cur的左子树入栈

/**
 * DeFinition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> arr = new ArrayList<>();
        if(root == null){
            return arr;
        }
        Deque<TreeNode> sta = new LinkedList<>();
        sta.push(root);
        while(!sta.isEmpty()){
            TreeNode cur = sta.pop();
            arr.add(cur.val);
            //先入右在入左，这样出栈的时候才能先出左再出右
            if(cur.right != null){
                sta.push(cur.right);
            }
            if(cur.left != null){
                sta.push(cur.left);
            }
        }
        return arr;
    }
}

2.中序的迭代遍历

/**
 * DeFinition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> arr = new ArrayList<>();
        if (root == null){
            return arr;
        }

        Deque<TreeNode> sta = new LinkedList<>();
        TreeNode cur = root;
        
        while(cur!=null || !sta.isEmpty()){
            //1.左
            while(cur!=null){
                sta.push(cur);
                cur = cur.left;
            }
            //2.根
            //此时cur为null，直接弹出栈顶元素
           cur = sta.pop();
           arr.add(cur.val);
           //3.右
           cur = cur.right;
        }
        return arr;
    }
}

3.后序遍历的迭代写法

/**
 * DeFinition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> arr = new ArrayList<>();
        if (root == null){
            return arr;
        }
        TreeNode cur = root;
        Deque<TreeNode> sta = new LinkedList<>();
        TreeNode prev = null;
        while(cur!=null || !sta.isEmpty()){
            //左
            while(cur!=null){
                sta.push(cur);
                cur = cur.left;
            }
            cur = sta.pop();
            if(cur.right==null || cur.right==prev){
                //根
                arr.add(cur.val);
                prev = cur;
                cur = null;
            }else{ //右
                sta.push(cur);
                cur = cur.right;
            }
        }
        return arr;
    }
}