二叉树的前序遍历

递归

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        dfs(root,list);
        return list;
    }

    public static void dfs(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        //中  左  右
        list.add(root.val);
        dfs(root.left,list);
        dfs(root.right,list);
    }
}

迭代
我们使用栈来进行迭代，过程如下：

• 初始化栈，并将根节点入栈；
• 当栈不为空时：
  • 弹出栈顶元素 node，并将值添加到结果中；
  • 如果 node 的右子树非空，将右子树入栈；
  • 如果 node 的左子树非空，将左子树入栈；

由于栈是“先进后出”的顺序，所以入栈时先将右子树入栈，这样使得前序遍历结果为 “根->左->右”的顺序。

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right != null){
                stack.push(node.right);
            }
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return list;
    }
}

二叉树的中序遍历

递归

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        dfs(root,list);
        return list;
    }

    public static void dfs(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        //左  中  右
        dfs(root.left,list);
        list.add(root.val);
        dfs(root.right,list);
    }
}

迭代
会先递归节点A，再递归B，再递归D，一个个压入递归栈。

中序遍历，在栈顶节点的右子节点压栈之前，要处理出栈节点的节点值，将它输出。

新入栈的右子节点（右子树），就是在递归它。和节点A、B、D的压栈一样，它们都是子树。
不同的子树要做同样的事情，一样要先将它的左子节点不断压栈，然后再出栈，带出右子节点入栈。

代码实现

// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}

二叉树的后序遍历

递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        dfs(root,list);
        return list;
    }

    public static void dfs(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        //左  右   中
        dfs(root.left,list);
        dfs(root.right,list);
        list.add(root.val);
    }
}

迭代
根据前序遍历改
前序遍历中左右—>中右左—>左右中(翻转)

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