代码随想录|Day 19

最新推荐文章于 2024-09-28 15:28:59 发布

东鹅鹅鹅

最新推荐文章于 2024-09-28 15:28:59 发布

阅读量337

点赞数 8

文章标签： c++

本文链接：https://blog.csdn.net/donge520/article/details/136172004

版权

文章介绍了如何在二叉搜索树中使用中序遍历和双指针技巧求最小绝对差，以及如何通过遍历和频率统计找到二叉搜索树中的众数。还讨论了如何利用回溯在二叉树中寻找最近公共祖先问题的解决方案。

摘要由CSDN通过智能技术生成

Day 19

一、思路

530. 二叉搜索树的最小绝对差

第一眼，我没有发现二叉搜索树这个特性。我有一个很直观的想法，就是先对他进行一个遍历吗？遍历把所有的值全部都保存到数组当中，然后再转化为对数组的操作。然后再遍历一次就可以得到这个最小值。那这个方法应该是可行的。

如果是二叉搜索树，我们就可以更进一步。二叉搜索树采用中序遍历，其实就是一个有序数组。我先试试这个【转换为数组】，成功写出来！！！。二、代码部分贴的是【双指针】的解法

/**
 * 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 midorder(TreeNode* root,vector<int>&temp){
        if(root==nullptr) return;
        midorder(root->left,temp);
        temp.push_back(root->val);
        midorder(root->right,temp);
    }
    int getMinimumDifference(TreeNode* root) {
        vector<int>temp;
        midorder(root,temp);
        int i=0;
        int j=1;
        int lest=99999999;
        while(j<temp.size()){
            if(abs(temp[i]-temp[j])<lest){
                lest=abs(temp[i]-temp[j]);
            }
            i++;
            j++;
        }
        return lest;

    }
};

501. 二叉搜索树中的众数 - 力扣（LeetCode）

1)如果不是二叉搜索树，最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

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

    }
};

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。

那么二叉树如何可以自底向上查找呢？

回溯啊，二叉树回溯的过程就是从低到上。

后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

接下来就看如何判断一个节点是节点q和节点p的公共祖先呢。

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

二、代码

530. 二叉搜索树的最小绝对差

530.二叉搜索树的最小绝对差

/**
 * 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 {
private:
    int res=INT_MAX;
    TreeNode* pre=nullptr;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;
        traversal(cur->left);
        if(pre!=nullptr){
            res=min(res,abs(pre->val-cur->val));
        }
        pre=cur;
        traversal(cur->right);
    }

public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return res;
    }
};

501. 二叉搜索树中的众数 - 力扣（LeetCode）

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==NULL) return root;
        if(root==p || root==q) return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);
        if(left!=NULL && right!=NULL) return root;
        if(left==NULL && right!=NULL) return right;
        else if(left!=NULL && right==NULL) return left;
        else return NULL;
    }
};