非递归二叉树

先序遍历（根 --> 左--> 右）：

思想：

1.把左子节点加入ans数组并入栈，左左子节点加入ans数组并入栈，左左左。。。。

2.左为null，pop()后把右子节点加入ans数组并入栈。

3.重复1操作

//对比代码， 前序遍历，唯一区别就是， 一个一直向左， 一个一直向右
public List<Integer> preorderTraversal(TreeNode root) {
  List<Integer> res = new ArrayList<>();
  Deque<TreeNode> stack = new ArrayDeque<>();

  while(root != null || !stack.isEmpty()){
    //go left down to the ground
    while(root != null){
      res.add(root.val);
      stack.push(root);
      root = root.left;
    }

    //if we reach to the leaf, go back to the parent right, and repeat the go left down.
    TreeNode cur = stack.pop();
    root = cur.right;
  }

  return res;
}

中序遍历（左 --> 根--> 右）：

思想：

1.把左子节点入栈，左左子节点入栈，左左左。。。。

2.左为null，node=pop() node.data加入ans数组，然后把node的右子节点入栈。

3.重复1操作

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;
}

后序遍历（左 --> 右-->根）：

仿照先序遍历（根-->左 --> 右）

就是（根-->右 --> 左）得到ans数组，然后颠倒数组顺序即可。

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new ArrayDeque<>();

        while(root != null || !stack.isEmpty()){
            while(root != null){
                res.add(root.val);
                stack.push(root);
                root = root.right;
            }

            TreeNode cur = stack.pop();
              root = cur.left;
        }
        
        Collections.reverse(res);
        return res;
    }