Java C++ 算法题解leetcode652寻找重复子树

更新时间：2022年09月14日 09:34:56 作者：AnjaVon

这篇文章主要为大家介绍了Java C++ 算法题解leetcode652寻找重复子树示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

题目要求

思路一：DFS+序列化

设计一种规则将所有子树序列化，保证不同子树的序列化字符串不同，相同子树的序列化串相同。
用哈希表存所有的字符串，统计出现次数即可。
- 定义map中的关键字（key）为子树的序列化结果，值（value）为出现次数。
此处采用的方式是在DFS遍历顺序下的每个节点后添加"-"，遇到空节点置当前位为空格。

Java

class Solution {
    Map<String, Integer> map = new HashMap<>();
    List<TreeNode> res = new ArrayList<>();
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        DFS(root);
        return res;
    }
    String DFS(TreeNode root) {
        if (root == null)
            return " ";
        StringBuilder sb = new StringBuilder();
        sb.append(root.val).append("-");
        sb.append(DFS(root.left)).append(DFS(root.right));
        String sub = sb.toString(); // 当前子树
        map.put(sub, map.getOrDefault(sub, 0) + 1);
        if (map.get(sub) == 2) // ==保证统计所有且只记录一次
            res.add(root);
        return sub;
    }
}

时间复杂度：O(n^2)
空间复杂度：O(n)

C++

要把节点值转换为字符串格式……呜呜呜卡了半天才意识到

class Solution {
public:
    unordered_map<string, int> map;
    vector<TreeNode*> res;
    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
        DFS(root);
        return res;
    }
    string DFS(TreeNode* root) {
        if (root == nullptr)
            return " ";
        string sub = "";
        sub += to_string(root->val); // 转换为字符串！！！
        sub += "-";
        sub += DFS(root->left);
        sub += DFS(root->right);
        if (map.count(sub))
            map[sub]++;
        else
            map[sub] = 1;
        if (map[sub] == 2) // ==保证统计所有且只记录一次
            res.emplace_back(root);
        return sub;
    }
};

时间复杂度：O(n^2)
空间复杂度：O(n)

Rust

在判定等于222的地方卡了好久，报错borrow of moved value sub，没认真学rust导致闭包没搞好，然后根据报错内容猜了下，把上面的加了个clone()果然好了。

use std::rc::Rc;
use std::cell::RefCell;
use std::collections::HashMap;
impl Solution {
    pub fn find_duplicate_subtrees(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
        let mut res = Vec::new();
        fn DFS(root: &Option<Rc<RefCell<TreeNode>>>, map: &mut HashMap<String, i32>, res: &mut Vec<Option<Rc<RefCell<TreeNode>>>>) -> String {
            if root.is_none() {
                return " ".to_string();
            }
            let sub = format!("{}-{}{}", root.as_ref().unwrap().borrow().val, DFS(&root.as_ref().unwrap().borrow().left, map, res), DFS(&root.as_ref().unwrap().borrow().right, map, res));
            *map.entry(sub.clone()).or_insert(0) += 1;
            if map[&sub] == 2 { // ==保证统计所有且只记录一次
                res.push(root.clone());
            }
            sub            
        }
        DFS(&root, &mut HashMap::new(), &mut res);
        res
    }
}

时间复杂度：O(n^2)
空间复杂度：O(n)

思路二：DFS+三元组

和上面其实差不多，三元组本质上也是一种序列化形式，可以指代唯一的子树结构：
- 三元组中的内容为(根节点值,左子树标识,右子树标识)(根节点值, 左子树标识,右子树标识)(根节点值,左子树标识,右子树标识)；
  - 这个标识是给每个不同结构的子树所赋予的唯一值，可用于标识其结构。
- 所以三元组相同则判定子树结构相同；
- 该方法使用序号标识子树结构，规避了思路一中越来越长的字符串，也减小了时间复杂度。
定义哈希表mapmapmap存储每种结构：
- 关键字为三元组的字符串形式，值为当前子树的标识和出现次数所构成的数对。
- 其中标识用从000开始的整数flagflagflag表示。

Java

class Solution {
    Map<String, Pair<Integer, Integer>> map = new HashMap<String, Pair<Integer, Integer>>();
    List<TreeNode> res = new ArrayList<>();
    int flag = 0;
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        DFS(root);
        return res;
    }
    public int DFS(TreeNode root) {
        if (root == null)
            return 0;  
        int[] tri = {root.val, DFS(root.left), DFS(root.right)};
        String sub = Arrays.toString(tri); // 当前子树
        if (map.containsKey(sub)) { // 已统计过
            int key = map.get(sub).getKey();
            int cnt = map.get(sub).getValue();
            map.put(sub, new Pair<Integer, Integer>(key, ++cnt));
            if (cnt == 2) // ==保证统计所有且只记录一次
                res.add(root);
            return key;
        }
        else { // 首次出现
            map.put(sub, new Pair<Integer, Integer>(++flag, 1));
            return flag;
        }
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

C++

class Solution {
public:
    unordered_map<string, pair<int, int>> map;
    vector<TreeNode*> res;
    int flag = 0;
    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
        DFS(root);
        return res;
    }
    int DFS(TreeNode* root) {
        if (root == nullptr)
            return 0;
        string sub = to_string(root->val) + to_string(DFS(root->left)) + to_string(DFS(root->right)); // 当前子树
        if (auto cur = map.find(sub); cur != map.end()) { // 已统计过
            int key = cur->second.first;
            int cnt = cur->second.second;
            map[sub] = {key, ++cnt};
            if (cnt == 2) // ==保证统计所有且只记录一次
                res.emplace_back(root);
            return key;
        } 
        else { // 首次出现
            map[sub] = {++flag, 1};
            return flag;
        }
    }
};

时间复杂度：O(n)
空间复杂度：O(n)

Rust

三元组不好搞，所以用了两个二元哈希表替代一个存放三元组和标识，另一个存放标识与出现次数。

use std::rc::Rc;
use std::cell::RefCell;
use std::collections::HashMap;
impl Solution {
    pub fn find_duplicate_subtrees(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
        let mut res = Vec::new();
        fn DFS(root: &Option<Rc<RefCell<TreeNode>>>, sub_flag: &mut HashMap<String, i32>, flag_cnt: &mut HashMap<i32, i32>, res: &mut Vec<Option<Rc<RefCell<TreeNode>>>>, flag: &mut i32) -> i32 {
            if root.is_none() {
                return 0;
            }
            let (lflag, rflag) = (DFS(&root.as_ref().unwrap().borrow().left, sub_flag, flag_cnt, res, flag), DFS(&root.as_ref().unwrap().borrow().right, sub_flag, flag_cnt, res, flag));
            let sub = format!("{}{}{}", root.as_ref().unwrap().borrow().val, lflag, rflag);
            if sub_flag.contains_key(&sub) { // 已统计过
                let key = sub_flag[&sub];
                let cnt = flag_cnt[&key] + 1;
                flag_cnt.insert(key, cnt);
                if cnt == 2 { // ==保证统计所有且只记录一次
                    res.push(root.clone());
                }
                key
            }
            else { // 首次出现
                *flag += 1;
                sub_flag.insert(sub, *flag);
                flag_cnt.insert(*flag, 1);
                *flag
            }
        }
        DFS(&root, &mut HashMap::new(), &mut HashMap::new(), &mut res, &mut 0);
        res
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

总结

两种方法本质上都是基于哈希表，记录重复的子树结构并统计个数，在超过111时进行记录，不过思路二更巧妙地将冗长的字符串变为常数级的标识符。

以上就是Java C++ 算法题解leetcode652寻找重复子树的详细内容，更多关于Java C++ 寻找重复子树的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

详解C语言中const关键字的用法
这篇文章主要对C语言中const关键字的用法进行了详细的分析介绍，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2015-08-08
C语言动态内存泄露常见问题内存分配改进方法详解
今天遇见了一道有意思的内存泄露题目，特地分享给大家，相信屏幕前的你学习完一定有所收获，预祝读者学习愉快，多多进步早日升职加薪
2021-10-10
判断指定的进程或程序是否存在方法小结(vc等)
VC判断进程是否存在？比如我想知道记事本是否运行，要用到哪些函数等实例，需要的朋友可以参考下
2013-01-01
VS Code 中安装运行、编写C语言程序的详细教程
这篇文章主要介绍了VS Code 中安装运行、编写C语言程序的详细教程,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2023-03-03
C语言数组快速入门详细讲解
数组是一组有序的数据的集合，数组中元素类型相同，由数组名和下标唯一地确定，数组中数据不仅数据类型相同，而且在计算机内存里连续存放，地址编号最低的存储单元存放数组的起始元素，地址编号最高的存储单元存放数组的最后一个元素
2022-05-05
详解C++中vector的理解以及模拟实现
vector是表示可变大小数组的序列容器。这篇文章主要为大家详细介绍了vector的理解以及模拟实现，文中的示例代码讲解详细，感兴趣的可以了解一下
2023-03-03
c++ class中成员与分配内存的问题详解
很多人都知道C++类是由结构体发展得来的,所以他们的成员变量（C语言的结构体只有成员变量）的内存分配机制是一样的,下面这篇文章主要给大家介绍了关于c++ class中成员与分配内存问题的相关资料,需要的朋友可以参考下
2021-10-10
C语言版停车位管理系统
这篇文章主要为大家详细介绍了C语言版停车位管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-03-03
C/C++经典算法之约瑟夫问题详解
这篇文章主要给大家介绍了关于C/C++经典算法之约瑟夫问题的相关资料,约瑟夫环问题是一道经典的数据结构的题目,本文介绍了解决约瑟夫问题的三种方法,需要的朋友可以参考下
2021-07-07
C++求1到n中1出现的次数以及数的二进制表示中1的个数
这篇文章主要介绍了C++求1到n中1出现的次数以及数的二进制表示中1的个数,两道基础的算法题目,文中也给出了解题思路,需要的朋友可以参考下
2016-02-02