865 具有所有最深节点的最小子树

题目描述：
给定一个根为 root 的二叉树，每个节点的深度是 该节点到根的最短距离 。
如果一个节点在 整个树 的任意节点之间具有最大的深度，则该节点是 最深的 。
一个节点的 子树 是该节点加上它的所有后代的集合。
返回能满足 以该节点为根的子树中包含所有最深的节点 这一条件的具有最大深度的节点。

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4]
输出：[2,7,4]
解释：
我们返回值为 2 的节点，在图中用黄色标记。
在图中用蓝色标记的是树的最深的节点。
注意，节点 5、3 和 2 包含树中最深的节点，但节点 2 的子树最小，因此我们返回它。

示例 2：
输入：root = [1]
输出：[1]
解释：根节点是树中最深的节点。

示例 3：
输入：root = [0,1,3,null,2]
输出：[2]
解释：树中最深的节点为 2 ，有效子树为节点 2、1 和 0 的子树，但节点 2 的子树最小。

提示：
树中节点的数量介于 1 和 500 之间。
0 <= Node.val <= 500
每个节点的值都是独一无二的。

方法1：
主要思路：解题链接汇总
（1）先计算出最深深度下的各个叶子结点；
（2）在找出这些叶子结点的最近公共祖先；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void find_max_depth(TreeNode* root,int&max_depth,unordered_set<int>&st,int cur_depth){//找出深度最深的所有叶子结点
        if(root==nullptr){
            return ;
        }
        if(max_depth==cur_depth){
            st.insert(root->val);
        }
        else if(max_depth<cur_depth){
            st.clear();//更新
            st.insert(root->val);
            max_depth=cur_depth;//更新最深的深度
        }
        find_max_depth(root->left,max_depth,st,cur_depth+1);
        find_max_depth(root->right,max_depth,st,cur_depth+1);
    }
    TreeNode* find_min_tree(TreeNode* root,unordered_set<int>&st){//找出最近公共祖先
        if(root==nullptr){
            return nullptr;
        }
        if(st.count(root->val)){
            return root;
        }
        TreeNode* left_node=find_min_tree(root->left,st);
        TreeNode* right_node=find_min_tree(root->right,st);
        if(left_node!=nullptr&&right_node!=nullptr){
            return root;
        }
        return left_node==nullptr?right_node:left_node;
    }
    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
        unordered_set<int> nodes;
        int max_depth=0;
        find_max_depth(root,max_depth,nodes,0);
        return find_min_tree(root,nodes);
    }
};

方法2：
主要思路：
（1）说过左右子树的高度差进行计算；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int get_depth(TreeNode*root){//当前结点小的最大深度
        if(root==nullptr){
            return 0;
        }
        return max(get_depth(root->left),get_depth(root->right))+1;
    }
    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
        int depth_left=get_depth(root->left);
        int depth_right=get_depth(root->right);
        if(depth_left==depth_right){//说明都包含了叶子结点
            return root;
        }
        else if(depth_left>depth_right){
            return subtreeWithAllDeepest(root->left);
        }
        else{
            return subtreeWithAllDeepest(root->right);
        }
    }
};