二叉树的前中后序遍历（递归+迭代）

前序遍历（根左右）

//递归
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> l=new ArrayList<>();
        preorder(root,l);
        return l;
    }

    public void preorder(TreeNode root, List<Integer> l){
        if (root==null) return;
        l.add(root.val);
        preorder(root.left,l);
        preorder(root.right,l);
    }
}

//迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (!stack.isEmpty() || root != null) {
            while (root != null) {
                res.add(root.val); //等同于递归的l.add(root.val);
                stack.push(root); //显式把递归里面的栈 建立起来 因为递归处理left之后要返回找到left的父节点 处理right
                root = root.left; //等同于准备处理preorder(root.left,l);
            }
            //结束while等同于 if (root==null) return;
            root = stack.pop(); //等同于preorder(root.left,l);已经结束
            root = root.right; //等同于准备处理preorder(root.right,l);
        }
        return res;
    }
}

中序遍历

//递归
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

//迭代
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        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;
    }
}

后序遍历

//递归
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }

    public void postorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

//迭代
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 = root.left;//等同于准备处理preorder(root.left,l);
            }
            root = stack.pop();//等同于preorder(root.left,l);已经结束
            if (root.right == null || root.right == prev) {//等同于preorder(root.right,l);已经结束
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);//递归处理右节点之前把当前root入栈
                root = root.right;//等同于准备处理preorder(root.right,l);
            }
        }
        return res;
    }
}