代码随想录训练营Day16:二叉树查找最近的公共祖先

1.501二叉搜索树中的众数

两种方法来求解一个二叉搜索树中的众数

1.使用通用的递归的方式来求解一个众数

思路：首先我们生成一个哈希表来存储一个数据的频数<数，频数>，然后写一个自定义的比较器，根据比较器将数组进行一个排序，最后输出一个结果。

重点：

1.二叉搜索树的中序遍历。确定一个返回值，终止条件和每一层的操作就按照中序遍历的递归方式进行改写。

2.vector<pair<int,int>>vec，其中对应的一个是一个有序对。vec.first是第一个值，vec.second对应的是第二个值。

3.比较器的设置

2.使用pre指针和搜索二叉树的性质来求解众数

1.先生成一个pre指针指向的是空指针

2.我们按照中序遍历的方式来进行一个遍历

3.对中序遍历的时候对中间节点的一个处理，分三种情况：1.pre节点为空节点，那么设置计数值为1。2.pre值不为空，判断当前值和pre值相等，则计数值+1，如果值不相等，那么计数值变为1.最后再对其更新pre值。

4.计数值判断，如果计数值大于最大计数值，那么这个值就是最大的，前面在result中的数据全部得删除，只写入这个，如果相等，那么需要把这个也写入到result中。

    /*
    bool static cmp(pair<int,int>& a,pair<int,int>& b){
        return a.second>b.second;
    }
    void searchBST(TreeNode* cur,unordered_map<int,int>& mp){
        if(cur == nullptr) return;
        searchBST(cur->left,mp);
        mp[cur->val]++;
        searchBST(cur->right,mp);
    }
    */
    vector<int> result;
    int count = 0;
    int maxcount = 0;
    TreeNode* pre = nullptr;
    void searchBST(TreeNode* node){
        if(node == nullptr)return;
        searchBST(node->left);
        if(pre == nullptr){
            count = 1;
        }else if(pre->val == node->val){
            count++;
            

        }else{
            count = 1;
        }
        if(count == maxcount){
                result.push_back(node->val);
            }
            if(count>maxcount){
                maxcount = count;
                result.clear();
                result.push_back(node->val);
            }
        pre = node;
        searchBST(node->right);
        return;
    }
    vector<int> findMode(TreeNode* root) {
        /*
        //第一种方法：使用递归的方式进行求解
        unordered_map<int,int> mp;//对应的一个数，频数
        vector<int> result;
        searchBST(root,mp);
        vector<pair<int,int>> vec(mp.begin(),mp.end());
        sort(vec.begin(),vec.end(),cmp);
        result.push_back(vec[0].first);
        for(int i=1;i<vec.size();i++){
            if(vec[i].second==vec[0].second){
                result.push_back(vec[i].first);
            }else{
                break;
            }
        }
        return result;
        */
        //第二种方法：使用搜索二叉树的性质来进行操作。
        //搜索二叉树的话，那么对应的生成的数组是一个有序的，只需要对其进行处理即可
        result.clear();
        searchBST(root);
        return result;
    }

2.236二叉树的最近公共祖先

回溯来完成对其的查找

1循环的返回值和输入，直接就是输入

2.循环的终止条件：分三种情况：1.该结点为空，代表没找到公共的祖先，返回当前值，如果该结点和p相等，那么在这个和这个后面的节点的公共祖先是p(因为我按照逐层遍历遇到的第一个非空的，那么不管在这个后面有没有q，这个结点一定是一个公共祖先结点)，同理遇到q也是一样的。

3.循环内的逻辑：先递归获得left和right，为对应的公共祖先。然后判断，分三种情况：1.如果left,right都是非空，那么代表一个结点在左边一个在右边，那么当前的root就是公共祖先。2.如果left非空，right为空，那么代表的就是公共结点在左边，就是左边那个节点为公共祖先。3.同理第三种也是类似。

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //使用回溯的算法来进行判断
        //循环终止的条件：1.到达了最后面都没找到，那么返回null,第二种情况遇到了p（为两个的公共祖先），返回p，遇到了q(为两个的公共祖先)，返回q
        if(root == p||root == q||root == NULL) return root;
        TreeNode* left = lowestCommonAncestor(root->left,p,q);
        TreeNode* right = lowestCommonAncestor(root->right,p,q);
        if(left!=NULL&& right != NULL){
            return root;//代表连个节点，一个在左边，一个在右边，那么这个节点就是公共节点
        }else if(left == NULL && right!=NULL){
            return right;//代表两个节点都在右边
        }else if(left != NULL && right == NULL){
            return left;
        }else{
            return NULL;
        }
    }

3.235二叉搜索树的最近公共祖先

相比于普通的二叉树，二叉搜索树的性质可以让查找公共祖先更加快。因为我们可以通过直接比较其值与两个节点的值的大小，确定移动方向或者返回值，从而确定最终的返回值。

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        /*
        //第一种根据二叉搜索树的性质进行查找,使用迭代的方法来解决问题
        while(root){
            if(root->val>p->val&& root->val>q->val){
                root = root->left;
            }else if(root->val<p->val && root->val<q->val){
                root = root->right;
            }else{
                return root;
            }
        }
        return root;
        */
        //第二种方法：使用一个回溯的方法进行查找
        if(root == NULL) return NULL;
        if(root->val>p->val&&root->val>q->val){
            TreeNode* left = lowestCommonAncestor(root->left,p,q);
            if(left!=NULL){
                return left;
            }
        }
        if(root->val<p->val&&root->val<q->val){
            TreeNode* right = lowestCommonAncestor(root->right,p,q);
            if(right!=NULL){
                return right;
            }
        }
        return root;
        
    }