day21|LeetCode：● 530.二叉搜索树的最小绝对差 ● 501.二叉搜索树中的众数 ● 236. 二叉树的最近公共祖先

最新推荐文章于 2024-06-18 16:27:13 发布

星轨道交

最新推荐文章于 2024-06-18 16:27:13 发布

阅读量70

点赞数 1

分类专栏：代码随想录一刷文章标签： leetcode 算法 c++ 数据结构蓝桥杯

本文链接：https://blog.csdn.net/qerwtrt4t/article/details/128463068

版权

代码随想录一刷专栏收录该内容

54 篇文章 5 订阅

订阅专栏

题目链接：530. 二叉搜索树的最小绝对差

一：思路

求两颗树的最小差值

我们可以先中序遍历再求出最小差值，但是在二叉树递归遍历更方便，双指针法，用两个指针分别指向一前一后结点，需要一个整形result来储存最小差值,当两个结点的差更小时就更新result,最后返回result。

需要用一个pre节点记录一下cur节点的前一个节点。

二.暴力法

class Solution {
private:
vector<int> vec;
void traversal(TreeNode* root) {
    if (root == NULL) return;
    traversal(root->left);
    vec.push_back(root->val); // 将二叉搜索树转换为有序数组
    traversal(root->right);
}
public:
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(root);
        if (vec.size() < 2) return 0;
        int result = INT_MAX;
        for (int i = 1; i < vec.size(); i++) { // 统计有序数组的最小差值
            result = min(result, vec[i] - vec[i-1]);
        }
        return result;
    }
};

三.递归法（双指针）

class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre = nullptr;
    vector<int>traversal(TreeNode* cur) {
        if (cur == nullptr) return;//终止条件
        traversal(cur->left);
        if (pre != nullptr) {//处理逻辑
          result = min(result, cur->val - pre->val);
        } 
        pre = cur;
        traversal(cur->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

四.递归三部曲

1.确定返回参数和参数类型：返回类型为void，因为最后存储结果到了全局变量中，参数为根结点，处理每一个结点当成根节点。

2.确定终止条件：遇到根结点的下一个结点为空就返回，

3.确定单层递归的逻辑：因为是搜索二叉树，所以我们就能用中序遍历，判断当前结点和上一结点的差距，再更新，每次处理完后都要更新结点。

五.理解

1.终止条件的遍历顺序：前序遍历

2.中序遍历是再中间写遍历条件，当遍历完左子树时写逻辑

题目链接：501. 二叉搜索树中的众数

一.思路

求二叉搜索数的众数有三种方法：

方法一：中序得到一个map，key记录结点的值，value为词频，排序输出。

方法二：两边遍历二叉树，第一遍靠中序求出最高频率来，第二遍把等于这个最高频率的结点的值加入结果集中。

方法三：和第二种方法还是用了双指针，但是这次用了一些技巧。先定义计词频器count,还有maxcount记录最高词频，还有前结点pre和和后结点cur,可以进入中序，必定会有值，因为没有值就先return了。进入判断pre是否为空,为空但因为有结点，计词器count++,如果不为空比较两个集结点，两个结点的值相等，计次器个数count++，否则不相等就count归1，最后判断这个词频是最大词频就会加入到结果集中，不是最大词频就不做处理，如果词频大于最大词频，就更新最大词频，删除以前的元素（因为那不是最大词频），加入新的最大词频结点。

问题：众数可能有很多个

二.map索引+中序数组

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;
    }
};

三.递归法（双指针）

class Solution {
public:
   TreeNode*pre = nullptr; 
   int count;
   int  maxcount;
    void traversal(TreeNode* cur, vector<int>& result) {
         if (cur == nullptr) return;//终止条件
         traversal(cur->left, result);//下面为递归逻辑
         if (pre == nullptr) count = 1;
         else if (pre->val == cur->val) count++;
         else count = 1;
         pre = cur;
         if (count == maxcount) result.push_back(cur->val);
         if (count > maxcount){
             result.clear();
             maxcount = count;
             result.push_back(cur->val);
         }
         traversal(cur->right, result);
     }
    vector<int> findMode(TreeNode* root) {
       
        vector<int>result;
        traversal(root, result);
        return result;
    }
};

四：关键代码

频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。

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

中序都是遍历完左节点后的逻辑

题目链接：236. 二叉树的最近公共祖先

一.思路

终止条件先序判断是否与p和q(要找的元素)相等，不相等就会到末尾返回空，相等就返回这个结点到递归函数

找到p和q的公共根结点后，回溯返回这个结点（后序）

二.递归法（后序）

class Solution {
public:
TreeNode* treversal(TreeNode* root, TreeNode* p, TreeNode* q) {
    if (root == NULL) return NULL;
    if (root == p || root == q) return root;
    TreeNode* left = treversal(root->left, p, q);
    TreeNode* right = treversal(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;
}
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    return treversal(root, p ,q);

    }
};