Leetcode 刷题笔记(十二) —— 二叉树篇之二叉树的前中后序遍历

系列文章目录

一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
更新中 … …

---

前言

刷题路线来自 ：代码随想录

二叉树：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
       this.right = right;
    }
}

二叉树的前中后序遍历表示，前中后其实指的就是中间节点的遍历顺序

题录

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
Leetcode 链接
题解：
方法一：递归法

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        preorder(root, list);
        return list;
    }
    public void preorder(TreeNode root, List<Integer> list) {
    	// 结束条件
        if (root == null) return;
        // 中 -> 左 -> 右
        list.add(root.val);
        preorder(root.left, list);
        preorder(root.right, list);
    }
}

方法二：迭代法一

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        // 先把根结点添加到栈中
        if (root != null) stack.push(root);
        while (!stack.isEmpty()) {
        	// 弹出栈顶元素，并添加到返回值中
            TreeNode node = stack.pop();
            res.add(node.val);
            // 右孩子 -> 左孩子 顺序入栈，弹出栈顶元素的顺序就是： 左孩子 -> 右孩子
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
        return res;
    }
}

方法二：迭代法二

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        // cur 用来遍历二叉树
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
            	// cur 不为空，添加结点 val 值到返回 List 中，并入栈保存遍历路径，然后 cur 向左走
                res.add(cur.val);
                stack.push(cur);
                cur = cur.left;
            } else {
            	// cur 向左走到头了，弹出栈顶结点，然后 cur 向右走
                cur = stack.pop();
                cur = cur.right;
            }
        }
        return res;
    }
}

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的 中序 遍历。
Leetcode 链接
题解：
方法一：递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        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<>();
        Stack<TreeNode> stack = new Stack<>();
        // cur 用来遍历二叉树
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
            	// cur 不为空，结点入栈，cur 向左走
                stack.push(cur);
                cur = cur.left;
            } else {
            	// 向左走到头了，弹出栈顶元素，添加 val 值到 list 中，cur 向右走
                cur = stack.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
}

145. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
Leetcode 链接
题解：
方法一：递归法

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        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);
    }
}

方法二：迭代法一
同前序遍历的迭代法一，因为后序遍历的顺序为 左 -> 右 -> 中 ，如果反过来看就是 中 -> 右 -> 左，只需改变前序遍历的迭代法一的左右孩子入栈顺序，以 中 -> 右 -> 左 的顺序遍历，最后反转 返回 List 就行

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
        	// 出栈时添加 val 值到返回 list 中
            TreeNode node = stack.pop();
            res.add(node.val);
            // 入栈顺序：左 -> 右，出栈顺序：右 -> 左
            if(node.left != null) stack.push(node.left);
            if(node.right != null) stack.push(node.right);
        }
        // 反转 list
        Collections.reverse(res);
        return res;
    }
}

方法三：迭代法二
因为在局部中父亲结点最后遍历，遍历右子树时，同上边一样先需要弹出父亲结点，这时还不能添加 val 值到返回列表中，因为右子树还没遍历，需要将弹出的结点再次添加到栈中。
只有右子树已经遍历或者没有右子树时，才能添加 val 到返回值中，那么怎么知道右子树已经遍历，这时就需要一个 prev 指针来记录上次遍历的结点

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        // cur 用来遍历
        TreeNode cur = root;
        // prev 用来记录上次遍历的个结点
        TreeNode prev = null;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.add(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                if (cur.right != null && cur.right != prev) {
                    // 有右子树并且右子树没遍历，需放回根结点到栈中
                    stack.push(cur);
                    // 接下来遍历右子树
                    cur = cur.right;
                } else {
                    // 没有右子树，或者右子树被遍历过，
                    res.add(cur.val);
                    // 更新前指针
                    prev = cur;
                    // 以该结点的子树都已遍历，下次需要从栈中取父亲结点向上遍历，所以 cur == null
                    cur = null;
                }
            }
        }
        return res;
    }
}