【数据结构与算法 | 灵神题单 | 遍历二叉树篇】力扣404， 872， 671，LCP44

Vez'nan的幸福生活

已于 2024-09-15 13:26:06 修改

阅读量761

点赞数 8

文章标签：算法

于 2024-09-15 11:12:34 首次发布

本文链接：https://blog.csdn.net/2301_80912559/article/details/142281398

版权

1. 力扣404：左叶子之和

1.1 题目：

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

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

提示:

节点数在 [1, 1000] 范围内
-1000 <= Node.val <= 1000

1.2 思路：

中序遍历递归，然后判断一下什么时候需要把节点的值加到sum上即可。

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 {
    int sum = 0;
    public int sumOfLeftLeaves(TreeNode root) {
        recursion(null, root);
        return sum;
    }
    private void recursion(TreeNode parent, TreeNode node) {
        if(node == null){
            return;
        }
        // 如果parent为null，就是根节点
        if(parent != null && parent.left == node && node.left == null && node.right == null){
            sum += node.val;
        }
        recursion(node, node.left);
        recursion(node, node.right);
    }
}

2. 力扣872：叶子节点相似的树

2.1. 题目：

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

示例 1：

输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出：true

示例 2：

输入：root1 = [1,2,3], root2 = [1,3,2]
输出：false

提示：

给定的两棵树结点数在 [1, 200] 范围内
给定的两棵树上的值在 [0, 200] 范围内

2.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 {
    List<Integer> list1 = new ArrayList<>();
    List<Integer> list2 = new ArrayList<>();
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        recursion(root1, list1);
        recursion(root2, list2);
        if(list1.size() != list2.size()){
            return false;
        }
        for(int i = 0; i < list1.size(); i++){
            // 这里有坑，如果直接写list1.get(i) != list2.get(i)
            // 会有个案例没通过，因为list集合里面元素是Integer类型的（引用数据类型）
            // 运算符比较的是地址，所以即使值一样，也有可能判断是不同。
            // 要么拆包成int，要么调用api
            if(Integer.compare(list1.get(i), list2.get(i)) != 0){
                return false;
            }
        }
        return true;
    }
    private void recursion(TreeNode node, List<Integer> list){
        if(node == null){
            return;
        }
        // 叶子节点直接拿下
        if(node.left == null && node.right == null){
            list.add(node.val);
            return;
        }
        recursion(node.left, list);
        recursion(node.right, list);
    }
}

3. 力扣671：二叉树中第二小的节点

3.1 题目：

给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。

更正式地说，即 root.val = min(root.left.val, root.right.val) 总成立。

给出这样的一个二叉树，你需要输出所有节点中的 第二小的值 。

如果第二小的值不存在的话，输出 -1 。

示例 1：

输入：root = [2,2,5,null,null,5,7]
输出：5
解释：最小的值是 2 ，第二小的值是 5 。

示例 2：

输入：root = [2,2,2]
输出：-1
解释：最小的值是 2, 但是不存在第二小的值。

提示：

树中节点数目在范围 [1, 25] 内
1 <= Node.val <= 231 - 1
对于树中每个节点 root.val == min(root.left.val, root.right.val)

3.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 {
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    public int findSecondMinimumValue(TreeNode root) {
        if(root == null){
            return -1;
        }
        recursion(root);
        // i1是树中最小的值
        int i1 = pq.poll();
        while(pq.size() > 0){
            int i2 = pq.poll();
            // 跟最小值一样就跳过，不一样则找到了直接返回
            if(i1 == i2){
                
            }else{
                return i2;
            }
        }
        return -1;

    }
    // 中序遍历用优先队列收集节点的值
    private void recursion(TreeNode node) {
        if(node == null){
            return;
        }
        pq.offer(node.val);
        recursion(node.left);
        recursion(node.right);
    }
}

4. 力扣LCP44：开幕式焰火

4.1 题目：

「力扣挑战赛」开幕式开始了，空中绽放了一颗二叉树形的巨型焰火。给定一棵二叉树 root 代表焰火，节点值表示巨型焰火这一位置的颜色种类。请帮小扣计算巨型焰火有多少种不同的颜色。

示例 1：

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

输出：3

解释：焰火中有 3 个不同的颜色，值分别为 1、2、3

示例 2：

输入：root = [3,3,3]

输出：1

解释：焰火中仅出现 1 个颜色，值为 3

提示：

1 <= 节点个数 <= 1000
1 <= Node.val <= 1000

4.2 思路：

用哈希表记录树中节点的值。如果在哈希表中从来没出现过，就加到哈希表，否则就不用处理。最后再返回哈希表的长度即可。没必要用hashmap，应该用HashSet。虽然底层都是哈希表。

4.3 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    HashMap<Integer, Integer> hashmap = new HashMap<>();
    public int numColor(TreeNode root) {
        recursion(root);
        return hashmap.size();
    }
    private void recursion(TreeNode node){
        if(node == null){
            return;
        }
        if(!hashmap.containsKey(node.val)){
            hashmap.put(node.val, 1);
        }
        recursion(node.left);
        recursion(node.right);
    }
}