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

最新推荐文章于 2024-07-25 19:34:38 发布
最新推荐文章于 2024-07-25 19:34:38 发布
阅读量36 收藏
点赞数
文章标签： leetcode 算法 数据结构 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52097561/article/details/128874946
版权

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

leetcode 501.二叉搜索树中的众数

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

leetcode 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:
    vector<int> tree;
    void traversal(TreeNode* cur){
        if(cur == NULL) return;
        traversal(cur->left);
        tree.push_back(cur->val);
        traversal(cur->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        if(tree.size() < 2) return 0;
        int result = INT_MAX;
        for(int i = 1; i < tree.size(); i++){
            result = min(result, tree[i] - tree[i - 1]);
        }
        return result;
    }
};

我们也可以在二叉树中序遍历的过程中就直接进行绝对差的计算与比较。

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

如图：

递归三部曲：

  1. 确定递归函数的参数和返回值

需要定义一个int类型的result值并初始赋值为INT_MAX，作为每次与节点的绝对差相比较的值。递归函数传入根节点，我们需要遍历整个二叉树且不用处理递归返回值，所以是void类型。

int result = INT_MAX;
TreeNode* pre = NULL;
void traversal(TreeNode* cur)

  1. 确定终止条件

当前节点为空节点时返回

if(cur == NULL) return;

  1. 确定单层递归的逻辑

按照中序（左中右）遍历整个二叉树，中是对节点进行处理的操作，这里比较新的绝对差与result的大小并赋值pre，使pre节点记录cur的前一个节点。

traversal(cur->left);
if(pre != NULL){
    result = min(result, cur->val - pre->val);
}
pre = cur;
traversal(cur->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;
    }
};

迭代法

根据之前写过的二叉树中序遍历迭代法，使用栈来实现迭代法：

/**
 * 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 getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int result = INT_MAX;
        while(cur != NULL || !st.empty()){
            if(cur != NULL){
                st.push(cur);
                cur = cur->left;
            }
            else{
                cur = st.top();
                st.pop();
                if(pre != NULL){
                    result = min(result, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

leetcode 501.二叉搜索树中的众数

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

普通二叉树做法：

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

具体步骤如下：

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

这里采用前序遍历（使用任何遍历法均可，总之就是要对二叉树从头到尾遍历一遍），代码如下：

void searchBST(TreeNode* root, unordered_map<int, int>& map){
    if(root == NULL) return;
    map[root->val]++;                // 中
    searchBST(root->left, map);      // 左
    searchBST(root->right, map);     // 右
}

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

C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序。所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair<int, int>类型的数据，第一个int为元素，第二个int为出现频率。

sort()函数可以对给定区间所有元素进行排序。它有三个参数sort(begin, end, cmp)，其中begin为指向待sort()的数组的第一个元素的指针，end为指向待sort()的数组的最后一个元素的下一个位置的指针，cmp参数为排序准则，cmp参数可以不写，如果不写的话，默认从小到大进行排序。如果我们想从大到小排序可以将cmp参数写为greater<int>()就是对int数组进行排序，当然<>中我们也可以写double、long、float等等。如果我们需要按照其他的排序准则，那么就需要我们自己定义一个bool类型的函数来传入。

代码如下：

bool static cmp(const pair<int, int>& a, const pair<int, int>& b){
    return a.second > b.second         // 从大到小排序
}
vector<pair<int, int>> vec(map.begin(), map.end());
sort(vec.begin(), vec.end(), cmp);

  1. 取前面高频的元素

此时数组vector中已经是存放着按照频率排好序的pair，那么把前面高频的元素取出来就可以了。注意要考虑到可能有多个众数的情况。

代码如下：

result.push_back(vec[0].first);
for(int i = 1; i < vec.size(); i++){
    if(vec[i].second == vec[0].second)
        result.push_back(vec[i].first);
    else
        break;        // 不是众数直接break出for循环
}

整体代码如下：

/**
 * 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:
    bool static cmp(const pair<int, int>& a, const pair<int, int>& b){
        return a.second > b.second;
    }
    void searchBST(TreeNode* cur, unordered_map<int, int>& map){
        if(cur == NULL) return;
        map[cur->val]++;
        searchBST(cur->left, map);
        searchBST(cur->right, map);
    }
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map;
        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++){
            if(vec[i].second == vec[0].second)
                result.push_back(vec[i].first);
            else
                break;
        }
        return result;
    }
};

二叉搜索树做法：

二叉搜索树的中序遍历是有序的。

在上一题中我们就使用了pre指针和cur指针的技巧，本题也类似。

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

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

代码如下：

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

因为要求最大频率的元素集合（注意是集合，不是一个元素，可以有多个众数）所以应该是先遍历一遍数组，找出最大频率（maxCount），然后再重新遍历一遍数组把出现频率为maxCount的元素放进集合。（因为众数有多个）。

但是这种方式遍历了两遍数组。

/*****

那么如何只遍历一遍呢？（使用下面的clear技巧）

/*****

如果 频率count 等于 maxCount（最大频率），当然要把这个元素加入到结果集中（以下代码为result数组），代码如下：

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

整体代码如下：

/**
 * 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 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 += 1;
        }
        else
            count = 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);
        return;
    }
public:
    vector<int> findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};

迭代法

直接使用中序遍历的栈模拟递归，代码框架与上题一模一样，只需更改对“中”的处理过程即可：

/**
 * 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> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        int maxCount = 0;
        int count = 0;
        vector<int> result;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        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 += 1;
                }
                else
                    count = 1;
                if(count == maxCount)
                    result.push_back(cur->val);
                if(count > maxCount){
                    maxCount = count;
                    result.clear();
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

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

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

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

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。那么二叉树如何可以自底向上查找呢？

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

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

由于题目中说：所有 Node.val 互不相同，即不存在相同节点。判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。

容易忽略一个情况，就是节点本身p(q)，它拥有一个子孙节点q(p)。 情况二：

其实情况一 和 情况二 代码实现过程都是一样的，也可以说，实现情况一的逻辑，顺便包含了情况二。

因为遇到 q 或者 p 就返回，这样也包含了 q 或者 p 本身就是 公共祖先的情况。

递归三部曲：

  1. 确定递归函数的参数和返回值

需要递归函数返回值，来告诉我们是否找到节点q或者p，那么返回值为bool类型

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

  1. 确定终止条件

遇到空的话，因为树都是空了，所以返回空。

那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。

代码如下：

if (root == q || root == p || root == NULL) return root;

  1. 确定单层递归的逻辑

值得注意的是本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断，但本题我们依然要遍历树的所有节点。

本题需要遍历整棵树，当找到最近公共祖先时一路返回最上层即可。

先用left和right接住左子树和右子树的返回值，代码如下：

TreeNode* left = lowestCommonAncestor(root->left, p, q);
TreeNode* right = lowestCommonAncestor(root->right, p, q);

如果left 和 right都不为空，说明此时root就是最近公共节点。这个比较好理解

如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。

如图：

图中节点10的左子树返回null，右子树返回目标值7，那么此时节点10的处理逻辑就是把右子树的返回值（最近公共祖先7）返回上去。

如果left和right都为空，则返回left或者right都是可以的，也就是返回空。

逻辑如下：

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

整体代码：

/**
 * 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);
        if (left != NULL && right != NULL) return root;

        if (left == NULL && right != NULL) return right;
        else if (left != NULL && right == NULL) return left;
        else  { //  (left == NULL && right == NULL)
            return NULL;
        }
    }
};
clementines_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AlgorithmAndLeetCode#itcharge-LeetCode-Py#0501. 二叉搜索树中的众数1
07-25
0501. 二叉搜索树中的众数标签：树、深度优先搜索、二叉搜索树、二叉树难度：简单题目大意给定一个有相同值的二叉搜索树（BST），要求找出 BST 中所有众数
leetcode530-leetcode:leetcode
06-30
leetcode 530 leetcode 二叉树 ...530.二叉搜索树的最小绝对差 572.另一个树的子树 589.N叉树的前序遍历 637.二叉树的层平均值 654.最大二叉树 700.二叉搜索树中的搜索 783.二叉搜索树节点最小距离
leetcode530-algorithm_exercise:Leetcode题解集合
06-30
leetcode 530 Leetcode题解集合 基础篇 数组、栈、队列 数组 滑动窗口 栈 队列 链表 92.反转链表2 ...offer22.链表中倒数第k个节点 ...从前序与中序遍历序列构造二叉树 ...530.二叉搜索树的最小绝对差 前缀和 回溯算法 笔记
lrucacheleetcode-LeetCode-Tencent50:Leetcode中Tencent50的代码和注释
06-29
lru cache leetcode LeetCode-Tencent50 Task0 最小栈 Task1 有效的括号 Task2 数组中的第K个最大元素 ...二叉搜索树的最近公共祖先 Task14 二叉树的最近公共祖先 Task15 LRU Cache Task16 Nim游戏
javalruleetcode-leetocode:leetcode解题记录
06-29
037-验证二叉搜索树 038-柱状图中最大的矩形 039-最大矩形 040-对称二叉树 041-二叉树的层次遍历 042-二叉树的最大深度 043-从前序与中序遍历序列构造二叉树 044-二叉树展开为链表 045-二叉树中的最大路径和 046-...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 646
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
【LeetCode】分隔链表
qq_26521261的博客
07-20 428
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Java | Leetcode Java题解之第273题整数转换英文表示
m0_57195758的博客
07-22 305
Java | Leetcode Java题解之第273题整数转换英文表示
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 283
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 244
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
力扣202.快乐数
最新发布
gyj215500的博客
07-25 131
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
【LeetCode】80.删除有序数组中的重复项II
说文科技，做有态度的研究。
07-21 228
思路很好想到，但是实现起来不是那么容易。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 554
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
leetcode 69. x 的平方根
m0_49013185的博客
07-24 212
可以使用二分查找法或牛顿迭代法来实现 LeetCode 问题。下面是使用二分查找法和牛顿迭代法的 C++ 实现。
leetcode4 -- 寻找两个正序数组的中位数
m0_65985318的博客
07-23 196
先将两数组合并，然后利用sort排序算法，对数组进行从小到大的排序，根据总长度是奇数或者偶数来决定中位数的位置。合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。合并数组 = [1,2,3] ，中位数 2。请你找出并返回这两个正序数组的。的正序（从小到大）数组。算法的时间复杂度应该为。
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 333
C++ | Leetcode C++题解之第275题H指数II
leetcode-104. 二叉树的最大深度
曼巴的博客
07-23 335
3）再逐渐往回返，每个当前层的长度为左右子树长度的较大值+1。是指从根节点到最远叶子节点的最长路径上的节点数。2）遍历到底部（叶子结点）时，当前层的长度为1。4）如果当前没节点，返回0。1）递归地从上向下走。
LeetCode 150, 112, 130
qq_61350148的博客
07-21 878
讲解了栈、二叉树、搜索相关的题目。
LeetCode 2844.生成特殊数字的最少操作：模拟（分析）
<font color="Pink">Tisfy的博客</font>
07-25 845
LeetCode 2844.生成特殊数字的最少操作：模拟（分析） 给你一个下标从 0 开始的字符串 num ，表示一个非负整数。 在一次操作中，您可以选择 num 的任意一位数字并将其删除。请注意，如果你删除 num 中的所有数字，则 num 变为 0。 返回最少需要多少次操作可以使 num 变成特殊数字。 如果整数 x 能被 25 整除，则该整数 x 被认为是特殊数字。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值