二叉树的前中后序非递归遍历

前序遍历

前序遍历最简单，无脑入栈无脑出栈，出栈的时候先入右再入左即可。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        LinkedList <TreeNode> stack = new LinkedList <> ();
        List <Integer> res = new ArrayList <> ();
        if(root == null) {
            return res;
        }
        stack.push(root);
        while(stack.size() != 0) {
            TreeNode temp = stack.pop();
            res.add(temp.val);
            if(temp.right != null) {
                stack.push(temp.right);
            }
            if(temp.left != null) {
                stack.push(temp.left);
            }
        }
        return res;
    }
}

中序遍历

中序遍历比较特殊，要有一个前驱指针p来一直向左试探，所以条件上多了一项p != null，一直试探到

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null) {
            return list;
        }
        LinkedList <TreeNode> stack = new LinkedList <> ();
        TreeNode p = root;
        while(p != null || stack.size() != 0) {
            if(p != null) {
                stack.push(p);
                p = p.left;
            } else {
                TreeNode tmp = stack.pop();
                list.add(tmp.val);
                p = tmp.right;
            }
        }
        return list;
    }
}

后序遍历

纯粹的后序遍历有点难，比较难记住。这里利用前序的思想写一个，对其稍作修改，每次添加都放到0下标，先入左后入右。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List <Integer> res = new ArrayList <> ();
        if(root == null){
           return res;
        }
        LinkedList <TreeNode> stack = new LinkedList <> ();
        stack.push(root);
        while(stack.size() != 0) {
            TreeNode tmp = stack.pop();
            res.add(0,tmp.val);
            if(tmp.left != null) {
               stack.push(tmp.left);
            }
            if(tmp.right != null) {
                stack.push(tmp.right);
            }
        }
        return res;
    }
}