🔥 LeetCode 热题 HOT 100: 94 && 96

203 阅读1分钟

“Offer 驾到,掘友接招!我正在参与2022春招打卡活动,点击查看活动详情。”

94. 二叉树的中序遍历

一、题目描述:

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

 

示例 1:

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

示例 2:

输入: root = []
输出: []

示例 3:

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

 

提示:

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

二、思路分析: 二叉树的中序遍历顺序 是 左 根 右

准备一个栈, 当栈非空或者 root 不为 null 时开始循环 当 root 不为 null时, 将其压入栈中, 将root 置为 root 的左子节点 循环此过程,直至root 为null

root 为 null 时, 从栈中弹出一个节点 node,添加到 ans 集合中, node 节点的右子节点不为null 时, 将root 置为 node 节点的右子节点 继续循环

三、AC 代码:

/**
 * 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) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> ans = new ArrayList<>();

        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }

            TreeNode node = stack.pop();
            ans.add(node.val);
            if(node.right != null){
                root = node.right;
            }
        }
        return ans;
    }
}

96. 不同的二叉搜索树

一、题目描述:

给你一个整数 n ,求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种?返回满足题意的二叉搜索树的种数。

 

示例 1:

输入: n = 3
输出: 5

示例 2:

输入: n = 1
输出: 1

 

提示:

  • 1 <= n <= 19

二、思路分析:

  • 动态规划 dp[n] 为 n 个节点组成的二叉搜索数的种类

考虑以每一个 i 位置的节点 作为根节点计算, 以 i 为 根节点时 , 左子树有 i 个节点 种类为dp[i], 右子树有 (len - 1 - i) 个节点, 种类为 dp[len - 1 - i]

i 节点作为根节点的种类 f[i] = dp[i] * dp[len - 1 - i]

dp[n] = f[0] + f[1] + ...+ f[n - 1]

三、AC 代码:

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;

        for(int i = 2; i <= n; i++){
            for(int j = 0; j < i; j++){
                dp[i] += dp[j] * dp[i - 1 - j];
            }
        }
        return dp[n];
    }
}