[Leetcode]Iterative preorder, inorder, postorder traversal

Preorder Traversal

Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

最简单的情况，先遍历中间节点，再压入右节点，再压入左节点。因为是最先遍历中间节点的，所以不用任何flag

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) 
            return res;
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.empty()) {
            TreeNode cur = stack.pop();
            if (cur == null)
                continue;
            
            res.add(cur.val);
            stack.push(cur.right);
            stack.push(cur.left);
        }
        
        return res;
    }

Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

Go the left until there is no non-null node, then add the val as the in node. then go to the right subtree

public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        
        Stack<TreeNode> st = new Stack<TreeNode>();
        TreeNode cur = root;
        
        while(!st.isEmpty() || cur != null) {
            if(cur != null) {
                st.push(cur);
                cur = cur.left;
            } else {
                TreeNode cur1 = st.pop();
                res.add(cur1.val);
                cur = cur1.right;
            }
        }
        return res;
    }

Postorder Traversal

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

Postorder是最难实现，因为需要考虑已经遍历过的点不能再遍历的问题，所以需要两个flag来维护

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        boolean lflag = true;
        boolean rflag = true;
        while (!stack.empty()) {
            while (lflag && stack.peek().left != null) {
                //当可以向左前进并且左子结点不为空时，加入左子结点
                stack.push(stack.peek().left);
            }
            if (rflag && stack.peek().right != null) {
                //当左子节点压栈结束之后压入右子结点
                stack.push(stack.peek().right);
                lflag = true;
            } else {
                //左右子结点都为空了之后，取出栈顶元素遍历
                TreeNode node = stack.pop();
                res.add(node.val);
                lflag = false;
                if (!stack.empty() && stack.peek().right == node) 
                    rflag = false;
                else
                    rflag = true;
            }
        }
        return res;
    }