Day24 530二叉搜索树的最小绝对差 501二叉搜索树中的众数 236二叉树的最近公共祖先

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

给你一棵所有节点为非负值的二叉搜索树,请你计算树中任意两节点的差的绝对值的最小值。

        注意本题是一个二叉搜索树,看到二叉搜索树要想到以下几点:按照中序遍历(左中右)之后的val是单调递增的。本题可以采用数组法,双指针法和迭代法来进行处理。

//数组法
class Solution {
private:
vector 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:
    TreeNode* pre = nullptr; 
    int result = INT_MAX; //存放最后的最小差结果
    void traversal(TreeNode* cur){
         if(!cur) return; //终止条件

        traversal(cur->left); //左

        if(pre) result = min(result, cur->val - pre->val); //中
        pre = cur; //让上一个结点等于当前结点

        traversal(cur->right); //右
    }

    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

//迭代法
class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack st;
        TreeNode* cur = root;
        TreeNode* pre = nullptr;
        int result = INT_MAX;
        while(cur || !st.empty()){
            if(cur){
                st.push(cur);
                cur = cur->left;
            }
            else{
                cur = st.top();
                st.pop();
                if(pre){
                    result = min(result, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

501 二叉搜索树中的众数

给定一个有相同值的二叉搜索树(BST),找出 BST 中的所有众数(出现频率最高的元素)。

        本题提供两种思路,一种是按照普通二叉树的方法,另一种是利用本题给出的二叉搜索树的做法,如果按照普通二叉树的做法,那么就要创建一个哈希表,unordered map,记录频次,之后排序求众数,如果利用二叉搜索树的方法,那么就是利用双指针法或者迭代法,具体代码如下:

//普通二叉树的方法
class Solution {
private:

void searchBST(TreeNode* cur, unordered_map& map) { // 前序遍历
    if (cur == NULL) return ;
    map[cur->val]++; // 统计元素频率 中
    searchBST(cur->left, map); //左
    searchBST(cur->right, map); //右
    return ;
}
//仿函数,提供降序排列,这样可以让第一个元素的频次一定是最高的
bool static cmp (const pair& a, const pair& b) { 
    return a.second > b.second;
}
public:
    vector findMode(TreeNode* root) {
        unordered_map map; // key:元素,value:出现频率
        vector result; //存放最后的结果
        if (root == NULL) return result;

        searchBST(root, map);
        
        //map可以通过key排序,但是不能通过value排序,所以我们把map转化为vector
        vector> 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:
    int MaxCount = 0; //记录最大的频率
    int count = 0; //记录每一组的频率
    vector result; //记录最终的结果
    TreeNode* pre = nullptr; //记录前一个指针

    void searchBST(TreeNode* cur){
        if(cur == nullptr) return;
        searchBST(cur->left); //左

        if(pre == nullptr) count = 1; //第一个要访问的元素
        else if(cur->val == pre->val) count++; //如果相同count+1
        else count =1; //不相同则归1
        pre = cur; //更新前一个指针,当然也可以写在后面

        if(count == MaxCount) result.push_back(cur->val); //如果频率封顶则进入结果集
        if(count > MaxCount){
            MaxCount = count; //新的最大频率
            result.clear(); //清空
            result.push_back(cur->val); //加入新的数值
        }
        
        searchBST(cur->right); //右
    }
    vector findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};
//迭代法
class Solution {
public:
    vector findMode(TreeNode* root) {
        stack st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int maxCount = 0; // 最大频率
        int count = 0; // 统计频率
        vector result;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点,访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top();
                st.pop();                       // 中
                if (pre == NULL) { // 第一个节点
                    count = 1;
                } else if (pre->val == cur->val) { // 与前一个节点数值相同
                    count++;
                } else { // 与前一个节点数值不同
                    count = 1;
                }
                if (count == maxCount) { // 如果和最大值相同,放进result中
                    result.push_back(cur->val);
                }

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

 236 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”

Day24 530二叉搜索树的最小绝对差 501二叉搜索树中的众数 236二叉树的最近公共祖先_第1张图片

         求最小公共祖先,需要从底往上遍历,所有要通过二叉树的后序遍历(即回溯)实现,回溯过程中,必须要遍历整颗二叉树,即使已经找到结果了,依然要把其他结点遍历完,因为要使用递归函数的返回值(right,left)做逻辑判断,对于什么时候返回值,什么时候不返回呢?

搜索一条边的写法:

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

 搜索整棵树的写法:

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

         如果要搜索一条边,递归函数返回值不为空的时候,立刻返回,如果搜索整棵树,要用变量接住返回值,这个变量后序还有逻辑处理的需要,也就是后序遍历中处理中间结点的逻辑(回溯)

         总而言之,不回溯的话,得到条件立刻返回即可,如果要回溯就要接住以后处理返回处理后的值。本题代码如下:

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr) return nullptr; //如果遍历到空节点,就返回空
        if(root == p || root == q) return root; //如果遍历到了p或者q,就不会继续遍历了,直接向上返回
        //采用后序遍历左右中的方法向上回溯,如果某一边不存在p或者q,就设置为空,否则就会向上返回
        TreeNode* left = lowestCommonAncestor(root->left, p, q); //左
        TreeNode* right = lowestCommonAncestor(root->right, p, q) ; //右
        if(left != nullptr && right != nullptr) return root; //如果左右节点都不为空,这就是公共祖先
        else if(left != nullptr && right == nullptr) return left; //左不空右空说明左子树右p或者q
        else if(left == nullptr && right != nullptr) return right; //和上面同理
        else return nullptr; //左右都为空,遍历结束
    }
};

你可能感兴趣的:(算法)