刷题日记12 | 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历

刷题日记12

二叉树的遍历

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候 还会介绍到。

那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：

• 深度优先遍历

  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）

• 广度优先遍历

  • 层次遍历（迭代法）

在深度优先遍历中：有三个顺序，前中后序遍历， 有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。

这里前中后，其实指的就是中间节点的遍历顺序，只要大家记住 前中后序指的就是中间节点的位置就可以了。

看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式

• 前序遍历：中左右
• 中序遍历：左中右
• 后序遍历：左右中

144. 二叉树的前序遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        traversal(root, res);
        return res;
    }   
    public void traversal(TreeNode root, List<Integer> res) {
        if(root == null) return;
        res.add(root.val);
        traversal(root.left, res);
        traversal(root.right, res);
    }
}

迭代法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Stack<TreeNode> s = new Stack<>();
        if(root != null) s.push(root);
        while(!s.isEmpty()){
            TreeNode node = s.peek();
            if(node != null){
                s.pop();
                if(node.right != null) s.push(node.right); //右
                if(node.left != null) s.push(node.left); //左
                s.push(node); //中
                s.push(null);
            }else{
                s.pop();
                res.add(s.pop().val);
            }
        }
        return res;
    }
}

145. 二叉树的后序遍历

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        traversal(root, res);
        return res;
    }
    public void traversal(TreeNode root, List<Integer> res){
        if(root == null) return;
        traversal(root.left, res);
        traversal(root.right, res);
        res.add(root.val);
    }
}

迭代法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Stack<TreeNode> s = new Stack<>();
        if(root != null) s.push(root);
        while(!s.isEmpty()){
            TreeNode node = s.peek();
            if(node != null){
                s.pop();
                s.push(node); //中
                s.push(null);
                if(node.right != null) s.push(node.right); //右
                if(node.left != null) s.push(node.left); //左
            }else{
                s.pop();
                res.add(s.pop().val);
            }
        }
        return res;
    }
}

94.二叉树的中序遍历

递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        traversal(root, res);
        return res;
    }
    public void traversal(TreeNode root, List<Integer> res) {
        if(root == null) return;
        traversal(root.left, res);
        res.add(root.val);
        traversal(root.right, res);
    }
}

迭代法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Stack<TreeNode> s = new Stack<>();
        if(root != null) s.push(root);
        while(!s.isEmpty()){
            TreeNode node = s.peek();
            if(node != null){
                s.pop();
                if(node.right != null) s.push(node.right); //右
                s.push(node); //中
                s.push(null);
                if(node.left != null) s.push(node.left); //左
            }else{
                s.pop();
                res.add(s.pop().val);
            }
        }
        return res;
    }
}