【代码随想录】Day 21 二叉树Ⅴ（BST最小差、众数、最小公共祖先）

Pearl。

已于 2023-08-08 15:32:31 修改

阅读量38

点赞数

文章标签：算法数据结构

于 2023-08-07 19:40:40 首次发布

本文链接：https://blog.csdn.net/weixin_43785314/article/details/132133047

版权

第一题：

力扣

已AC，但是用的比较笨的vector存每个节点值，然后sort排序，再遍历一遍排序后的vector求出mindiff，无语死了，一直理解成了与节点值最小的差值，搞得绕了了老半天：

class Solution {
public:
    vector<int> val;

    void travel(TreeNode* node) {
        if (node == nullptr) return;
        travel(node->left);
        val.push_back(node->val);
        travel(node->right);
    }

    int getMinimumDifference(TreeNode* root) {
        travel(root);
        int diff = INT32_MAX;
        sort(val.begin(), val.end());
        for (int i = 1; i < val.size(); i++) {
            if ((val[i] - val[i-1]) < diff) {
                diff = val[i] - val[i-1];
            }
        }
        return diff;
    }
};

学习记录：

服了，看到题解才知道原来是一棵二叉搜索树，那sort都不用了，而且也不用vector存这么复杂了，直接node和node->left比一下差值，再和node->right比一下差值，返回这俩中小的一个就行了：

class Solution {
private:
int result = INT_MAX;
TreeNode* pre = NULL;
void traversal(TreeNode* cur) {
    if (cur == NULL) return;
    traversal(cur->left);   // 左
    if (pre != NULL){       // 中
        result = min(result, cur->val - pre->val);
    }
    pre = cur; // 记录前一个
    traversal(cur->right);  // 右
}
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。同时要学会在递归遍历的过程中如何记录前后两个指针！！！

第二题：

力扣

想到的是用map记录val以及val出现的次数，但是对map排序又要把它转成vector排序，觉得很麻烦，所以没有写，代码随想录上写的普通二叉树的代码和我的思路一样：

class Solution {
private:

void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
    if (cur == NULL) return ;
    map[cur->val]++; // 统计元素频率
    searchBST(cur->left, map);
    searchBST(cur->right, map);
    return ;
}
bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
    return a.second > b.second;
}
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map; // key:元素，value:出现频率
        vector<int> result;
        if (root == NULL) return result;
        searchBST(root, map);
        vector<pair<int, int>> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp); // 给频率排个序
        result.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

但是这道题求的是二叉搜索树，二叉搜索树是有序的，所以可以用中序遍历做，记录一下当前的count和最大的count。其实自己也想到了这个方法，但是有点绕，一时没捋清楚所以没写，后面看了一点代码随想录以后写的如下：

class Solution {
public:
    int maxCount = 1;
    int count = 1;
    TreeNode* pre = nullptr;
    vector<int> res;

    void traversal(TreeNode* node) {
        if (node == nullptr) return;
        traversal(node->left);
        if (pre != nullptr) {
            if (node->val == pre->val) { //当前值=前个值
                count++;
                }
            else { //当前值≠前个值
                count = 1; //count重置
                }
            if (count > maxCount) { //maxCount重置
                    maxCount = count;
                    res.clear(); //结果数组重置
                    res.push_back(pre->val); //存入新的结果
                }
            else if (count == maxCount) { //存入多个众数
                    res.push_back(node->val);
            }

        }
        else res.push_back(node->val); //如果只有一个根节点，把自己存进去
        pre = node;
        traversal(node->right);
    }

    vector<int> findMode(TreeNode* root) {
        traversal(root);
        return res;
    }
};

代码随想录写的和我写的有一点区别在于，我将所有操作都是放在if (pre != null)里的，而他是只写关于count的操作，剩下的和maxCount的比较是放在if (pre)外面的。

class Solution {
private:
    int maxCount = 0; // 最大频率
    int count = 0; // 统计频率
    TreeNode* pre = NULL;
    vector<int> result;
    void searchBST(TreeNode* cur) {
        if (cur == NULL) return ;

        searchBST(cur->left);       // 左
                                    // 中
        if (pre == NULL) { // 第一个节点
            count = 1;
        } else if (pre->val == cur->val) { // 与前一个节点数值相同
            count++;
        } else { // 与前一个节点数值不同
            count = 1;
        }
        pre = cur; // 更新上一个节点

        if (count == maxCount) { // 如果和最大值相同，放进result中
            result.push_back(cur->val);
        }

        if (count > maxCount) { // 如果计数大于最大值频率
            maxCount = count;   // 更新最大频率
            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
            result.push_back(cur->val);
        }

        searchBST(cur->right);      // 右
        return ;
    }

public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        TreeNode* pre = NULL; // 记录前一个节点
        result.clear();

        searchBST(root);
        return result;
    }
};

第三题：

力扣

思路是找到从根节点到节点p和q的路径，路径上每一个节点都存入vector<TreeNode*> path中，然后对两条path取交集，找到交集中最后的那一个，就是最近公共祖先，已AC：

class Solution {
public:
    vector<TreeNode*> res;
    vector<TreeNode*> path;

    bool findAncestor(TreeNode* node, TreeNode* p) { //bool类型，只有当node==要找的节点时才返回true，并且将路径存入res，否则都是false
        if (node == NULL) {
            return false;
        }
        path.push_back(node);
        if (node == p) {
            res = path;
            return true;
        }
        bool left = findAncestor(node->left, p);
        bool right = findAncestor(node->right, p);
        path.pop_back();
        return left || right;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == NULL || p == NULL || q == NULL) return NULL;
        findAncestor(root, p);
        vector<TreeNode*> p_Ancestor = res;
        res.clear();
        path.clear();
        findAncestor(root, q);
        vector<TreeNode*> q_Ancestor = res;
        TreeNode* result = NULL;
        for (int i = 0; i < min(p_Ancestor.size(), q_Ancestor.size()); i++) {
            if (p_Ancestor[i] == q_Ancestor[i]) result = p_Ancestor[i];
        }
        return result;
    }
};

学习记录：

如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。

递归三部曲：

递归函数返回值TreeNode*，参数TreeNode* node，TreeNode* p，TreeNode* q；
终止条件：当node == null, return null;
单层递归逻辑，当node == p || node == q，return p || q；

TIPS:如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？

搜索一条边的写法：
if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;
搜索整个树写法：
left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

这代码有点东西，结合图看更容易理解：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* 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;//说明p和q都找到了

        if (left == NULL && right != NULL) return right;
        else if (right == NULL && left != NULL) return left;
        else return NULL;
    }
};

Pearl。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【代码随想录】Day 21 二叉树Ⅴ（BST最小差、众数、最小公共祖先）

但是这道题求的是二叉搜索树，二叉搜索树是有序的，所以可以用中序遍历做，记录一下当前的count和最大的count。代码随想录写的和我写的有一点区别在于，我将所有操作都是放在if (pre!= null)里的，而他是只写关于count的操作，剩下的和maxCount的比较是放在if (pre)外面的。TIPS:如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？
复制链接

扫一扫