树(前序、中序、后序)

前序、中序、后序遍历

可以看一下LeetCode144、145/94

1. 使用递归实现前、中、后序遍历

1.1 前序：

void dfs(TreeNode root) {
    visit(root);
    dfs(root.left);
    dfs(root.right);
}

1.2 中序

void dfs(TreeNode root) {
    dfs(root.left);
    visit(root);
    dfs(root.right);
}

1.3 后序

void dfs(TreeNode root) {
    dfs(root.left);
    dfs(root.right);
    visit(root);
}

2. 使用非递归实现前、中、后序遍历

2.1 前序：

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

2.2 后序

前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。

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

2.2 中序

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