代码随想录算法训练营第day20|530.二叉搜索树的最小绝对差 、 501.二叉搜索树中的众数 、236. 二叉树的最近公共祖先

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

力扣题目链接

(opens new window)

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

示例：

提示：树中至少有 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 {
public:
    //数组版
    vector<int>vec;
    void traversal(TreeNode* root){
        if(root==nullptr)return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
        return;
    }
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(root);

        int mindff=INT_MAX;
        for(int i=1;i<vec.size();i++){
            if(mindff>abs(vec[i]-vec[i-1])){
                mindff=abs(vec[i]-vec[i-1]);
            }
        }
        return mindff;
    }
};

/**
 * 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:
    //二叉树版，记录前节点
    TreeNode* pre=nullptr;
    int result =INT_MAX;
    void traversal(TreeNode* root){
        if(root==nullptr)return;
        traversal(root->left);
        if(pre!=nullptr){
            result=min(result,root->val-pre->val);
        }
        pre=root;
        traversal(root->right);
        return;
    }
    int getMinimumDifference(TreeNode* root) {
        
        traversal(root);       
        return result;
    }
};

501.二叉搜索树中的众数

力扣题目链接

(opens new window)

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

假定 BST 有如下定义：

• 结点左子树中所含结点的值小于等于当前结点的值
• 结点右子树中所含结点的值大于等于当前结点的值
• 左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

思路：

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

具体步骤如下：

1.这个树都遍历了，用map统计频率

2.把统计的出来的出现频率（即map中的value）排个序

有的同学可能可以想直接对map中的value排序，还真做不到，C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序。

所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair<int, int>类型的数据，第一个int为元素，第二个int为出现频率。

3.取前面高频的元素

此时数组vector中已经是存放着按照频率排好序的pair，那么把前面高频的元素取出来就可以了。

是二叉搜索树，那么中序遍历就是一个有序数组，遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，然后就把出现频率最高的元素输出就可以了。

关键是在有序数组上的话，好搞，在树上怎么搞呢？

这就考察对树的操作了。

在二叉树：搜索树的最小绝对差

(opens new window)中我们就使用了pre指针和cur指针的技巧，这次又用上了。

弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。

而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。

/**
 * 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:
    int maxcount=0;
    int count=0;
    vector<int>result;
    TreeNode* pre=nullptr;
    void searchBST(TreeNode* cur){
        if(cur==nullptr) return;
        //左
        searchBST(cur->left);
        //中
        //处理次数
        if(pre==nullptr){
            count=1;//第一个节点
        }
        else if(pre->val==cur->val){
            count++;//节点数值相同，+1；
        }else count=1;//节点数值不同，重新置1；

        pre=cur;//更新pre;
        //更新result数组
        if(count==maxcount) result.push_back(cur->val);
        else if(count>maxcount){//如果次数大于maxcount,更新maxcount并清空原来结果数组的数值并重新加入
            maxcount=count;
            result.clear();
            result.push_back(cur->val);
        }
        searchBST(cur->right);//更新cur;


    }
    vector<int> findMode(TreeNode* root) {
        result.clear();
        searchBST(root);
        return result;
    }
};

236. 二叉树的最近公共祖先

力扣题目链接

(opens new window)

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

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

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉树中。

 

思路：

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

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

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

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

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

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

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

/**
 * 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==q||root==p||root==NULL) return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);//左
        TreeNode* right=lowestCommonAncestor(root->right,p,q);//右
        //中，注意题目说 p!= q且p 和 q 均存在于给定的二叉树中，说明肯定能找到pq
        if(left!=nullptr&&right!=nullptr)return root;//在左右子树中找到了，那么根就是公共祖先；
        if(left==nullptr) return right;//左子树没找到，那就是在右子树中，返回右子树根节点
        return left;

    }
};

参考：代码随想录