leetcode
leetcode 551 ~ 600
寻找重复的子树

寻找重复的子树

难度:

标签:

题目描述

给你一棵二叉树的根节点 root ,返回所有 重复的子树

对于同一类的重复子树,你只需要返回其中任意 一棵 的根结点即可。

如果两棵树具有 相同的结构相同的结点值 ,则认为二者是 重复 的。

 

示例 1:

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

示例 2:

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

示例 3:

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

 

提示:

  • 树中的结点数在 [1, 5000] 范围内。
  • -200 <= Node.val <= 200

代码结果

运行时间: 32 ms, 内存: 17.9 MB


/*
 * 题目思路:
 * 同样地,我们需要找到二叉树中的重复子树。我们使用Java Stream API来实现序列化子树并检测重复。
 * 使用递归和Collector将子树的序列化表示聚合到一个列表中,然后利用Collectors.groupingBy来分组计算相同子树的出现次数。
 * 最后筛选出重复的子树。
 */
 
import java.util.*;
import java.util.stream.*;
 
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}
 
public class Solution {
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        return findDuplicates(root).values().stream()
                .filter(list -> list.size() > 1)
                .map(list -> list.get(0))
                .collect(Collectors.toList());
    }
    
    private Map<String, List<TreeNode>> findDuplicates(TreeNode node) {
        if (node == null) return new HashMap<>();
        
        Map<String, List<TreeNode>> leftMap = findDuplicates(node.left);
        Map<String, List<TreeNode>> rightMap = findDuplicates(node.right);
        
        String serial = node.val + "," + leftMap.keySet().stream().findFirst().orElse("#") + "," + rightMap.keySet().stream().findFirst().orElse("#");
        
        Map<String, List<TreeNode>> currentMap = new HashMap<>();
        currentMap.put(serial, new ArrayList<>(Arrays.asList(node)));
        
        leftMap.forEach((key, value) -> currentMap.merge(key, value, (l1, l2) -> { l1.addAll(l2); return l1; }));
        rightMap.forEach((key, value) -> currentMap.merge(key, value, (l1, l2) -> { l1.addAll(l2); return l1; }));
        
        return currentMap;
    }
}

解释

方法:

这个题解使用了深度优先搜索(DFS)和哈希表来查找重复的子树。主要思路如下: 1. 定义一个DFS函数,用于遍历二叉树的每个节点。 2. 对于每个节点,创建一个元组 `(node.val, dfs(node.left), dfs(node.right))`,表示以该节点为根的子树的结构。 3. 使用哈希表 `seen` 存储已遍历过的子树结构。如果当前子树结构已经在哈希表中出现过,说明找到了一个重复的子树,将其加入到输出集合 `output` 中。 4. 为了区分不同的子树结构,使用一个递增的索引 `idx`,为每个新的子树结构分配一个唯一的索引。 5. 最后返回输出集合 `output` 中的所有重复子树的根节点。

时间复杂度:

O(n)

空间复杂度:

O(n)

代码细节讲解

🦆
题解中提到使用DFS和哈希表来查找重复的子树,但具体如何区分两个结构相同但节点值不同的子树?
在题解中,每个子树的结构通过一个元组(tri)来表示,这个元组包含了当前节点的值、左子树的索引和右子树的索引。因此,即使两个子树在结构上看似相同,如果它们的节点值不同,它们的元组表示也会不同。例如,对于节点值不同的两个子树,即使它们的子树结构相同,由于节点值的不同,生成的元组也会不同,从而使得这两个子树可以被区分开来。
🦆
在题解中,元组(tri)是如何确保唯一性的?即如何保证不同的子树结构不会生成相同的元组?
在题解中,元组(tri)的唯一性是通过包含三个关键信息来实现的:当前节点的值、左子节点的递归调用返回的索引和右子节点的递归调用返回的索引。索引是基于子树结构递归定义的,意味着即便两个子树在结构上相似,如果它们的任何一个子节点不同(包括值和子树结构),递归调用返回的索引也会不同。这种方法通过深度优先搜索确保了每一个独特的子树结构在哈希表中都有一个唯一的代表,从而保证了元组的唯一性。
🦆
题解提到使用一个递增的索引idx来标识不同的子树结构,这个索引有什么具体的作用?是否可以省略?
索引idx在算法中起到了为每个独特的子树结构分配一个唯一标识符的作用。这个标识符用于在哈希表中存储和检索子树结构,使得我们能够快速判断一个子树是否在之前已经出现过。尽管在某些实现中可以通过直接使用子树结构的序列化字符串作为键来省略这个索引,但使用索引可以减少哈希表中字符串的存储需求,并可能提高效率。因此,这个索引虽然理论上可以省略,但在实践中有其具体的优势。
🦆
题解中定义的输出集合output是一个set,这是否意味着如果有多个相同的子树结构只会返回一个根节点?
是的,输出集合output使用set数据结构意味着其中存储的元素是唯一的。在本题解中,如果二叉树中存在多个相同的子树结构,即使这些结构来自不同的位置,set将只保存它们的一个代表节点。这样做的目的是确保找到的每一个重复子树只被记录一次,从而避免重复输出相同的子树根节点。

相关问题

二叉树的序列化与反序列化

序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。

 

示例 1:

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

示例 2:

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

示例 3:

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

示例 4:

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

 

提示:

  • 树中结点数在范围 [0, 104]
  • -1000 <= Node.val <= 1000

序列化和反序列化二叉搜索树

序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建。

设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串,并且可以将该字符串反序列化为最初的二叉搜索树。

编码的字符串应尽可能紧凑。

 

示例 1:

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

示例 2:

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

 

提示:

  • 树中节点数范围是 [0, 104]
  • 0 <= Node.val <= 104
  • 题目数据 保证 输入的树是一棵二叉搜索树。

根据二叉树创建字符串

给你二叉树的根节点 root ,请你采用前序遍历的方式,将二叉树转化为一个由括号和整数组成的字符串,返回构造出的字符串。

空节点使用一对空括号对 "()" 表示,转化后需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

 

示例 1:

输入:root = [1,2,3,4]
输出:"1(2(4))(3)"
解释:初步转化后得到 "1(2(4)())(3()())" ,但省略所有不必要的空括号对后,字符串应该是"1(2(4))(3)" 。

示例 2:

输入:root = [1,2,3,null,4]
输出:"1(2()(4))(3)"
解释:和第一个示例类似,但是无法省略第一个空括号对,否则会破坏输入与输出一一映射的关系。

 

提示:

  • 树中节点的数目范围是 [1, 104]
  • -1000 <= Node.val <= 1000