40-算法打卡-二叉树-深度优先(前、中、后序遍历)-递归遍历-第四十天

1 递归思路

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

2 深度优先

2.1 前序遍历

前序遍历（VLR）， [1]是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右。前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。

确定递归函数的参数和返回值：函数的参数需要包含当前节点，以及返回结果集合
         public void preorder(TreeNode currNode, List<Integer> resultList)
确定终止条件：当前节点的为NULL的时候终止
确定单层递归的逻辑：
        resultList.add(currNode.val);
        preorder(currNode.left, resultList);
        preorder(currNode.right, resultList);

2.1.1 题目地址

144. 二叉树的前序遍历 - 力扣（LeetCode）144. 二叉树的前序遍历 - 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例 1：输入：root = [1,null,2,3]输出：[1,2,3]解释：[https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png]示例 2：输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]输出：[1,2,4,5,6,7,3,8,9]解释：[https://assets.leetcode.com/uploads/2024/08/29/tree_2.png]示例 3：输入：root = []输出：[]示例 4：输入：root = [1]输出：[1] 提示： * 树中节点数目在范围 [0, 100] 内 * -100 <= Node.val <= 100 进阶：递归算法很简单，你可以通过迭代算法完成吗？https://leetcode.cn/problems/binary-tree-preorder-traversal/

2.1.2 题目描述

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]

输出：[1,2,3]

解释：

示例 2：

输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[1,2,4,5,6,7,3,8,9]

解释：

示例 3：

输入：root = []

输出：[]

示例 4：

输入：root = [1]

输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

2.1.3 代码实现

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        // 存放结果
        List<Integer> resultList = new ArrayList<>();
        preorder(root, resultList);
        return resultList;
    }

    public void preorder(TreeNode currNode, List<Integer> resultList) {
        // 递归出口
        if (currNode == null) return;
        // 先序：存储根节点结果
        resultList.add(currNode.val);
        // 遍历左子树
        preorder(currNode.left, resultList);
        // 遍历右子树
        preorder(currNode.right, resultList);
    }
}

2.2 中序遍历

中序遍历是二叉树遍历的一种，也叫做中根遍历、中序周游。在二叉树中，中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。

2.2.1 题目地址

94. 二叉树的中序遍历 - 力扣（LeetCode）94. 二叉树的中序遍历 - 给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。 示例 1：[https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg]输入：root = [1,null,2,3]输出：[1,3,2]示例 2：输入：root = []输出：[]示例 3：输入：root = [1]输出：[1] 提示： * 树中节点数目在范围 [0, 100] 内 * -100 <= Node.val <= 100 进阶: 递归算法很简单，你可以通过迭代算法完成吗？https://leetcode.cn/problems/binary-tree-inorder-traversal/

2.2.2 题目描述

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

2.2.3 代码实现

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> resultList = new ArrayList<>();
        middleOrder(root, resultList);
        return resultList;
    }

    public void middleOrder(TreeNode currNode, List<Integer> resultList) {
        if (currNode == null) return;
        middleOrder(currNode.left, resultList);
        resultList.add(currNode.val);
        middleOrder(currNode.right, resultList);
    }
}

2.3 后序遍历

后序遍历（LRD）是二叉树遍历的一种，也叫做后根遍历、后序周游，可记做左右根。后序遍历有递归算法和非递归算法两种。在二叉树中，先左后右再根，即首先遍历左子树，然后遍历右子树，最后访问根结点。

2.3.1 题目地址

145. 二叉树的后序遍历 - 力扣（LeetCode）145. 二叉树的后序遍历 - 给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。 示例 1：输入：root = [1,null,2,3]输出：[3,2,1]解释：[https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png]示例 2：输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]输出：[4,6,7,5,2,9,8,3,1]解释：[https://assets.leetcode.com/uploads/2024/08/29/tree_2.png]示例 3：输入：root = []输出：[]示例 4：输入：root = [1]输出：[1] 提示： * 树中节点的数目在范围 [0, 100] 内 * -100 <= Node.val <= 100 进阶：递归算法很简单，你可以通过迭代算法完成吗？https://leetcode.cn/problems/binary-tree-postorder-traversal/description/

2.3.2 题目描述

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]

输出：[3,2,1]

解释：

示例 2：

输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[4,6,7,5,2,9,8,3,1]

解释：

示例 3：

输入：root = []

输出：[]

示例 4：

输入：root = [1]

输出：[1]

提示：

• 树中节点的数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

2.3.3 代码实现

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> resultList = new ArrayList<>();
        afterOrder(root, resultList);
        return resultList;
    }

    public void afterOrder(TreeNode currNode, List<Integer> resultList) {
        if (currNode == null) return;
        afterOrder(currNode.left, resultList);
        afterOrder(currNode.right, resultList);
        resultList.add(currNode.val);
    }
}