二叉树前中后序遍历迭代实现

二叉树遍历迭代实现
迭代用栈实现：递归的原理就是栈，每次调用一个方法就会开辟一个栈帧，而每个栈帧的返回顺序也是按照后进先出的顺序。所以基于这个原理，任何递归能解决的问题都可以转换为迭代去实现。
只需记住一点：栈是先进后出。
前序是根-左-右，那么栈的入栈顺序是根（此时进行出栈操作并添加到结果）-右-左；
中序是左-根-右，那么栈的入栈顺序是跟-左（一直到左子结点为空时进行出栈操作并添加到结果）-右（在返回到根）；
后序是左-右-根，那么栈的入栈顺序是根-右-左。
首先给出二叉树的结点定义

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) {
        if(root==null) return new ArrayList<Integer>();
        List<Integer> res=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            res.add(node.val);
            if(node.right!=null)
            stack.push(node.right);
            if(node.left!=null)
            stack.push(node.left);
        }
        return res;
    }
}

中序遍历：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            res.add(root.val);
            root=root.right;
        }
        return res;
    }
}

后序遍历
方法1：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root==null) return(new ArrayList<Integer>());
        LinkedList<Integer> res=new LinkedList<>();
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            res.addFirst(node.val);
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        return res;
    }
}

方法2来自力扣官方题解

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}