_18LeetCode代码随想录算法训练营第十八天-C++二叉树 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236.二叉树的最近公共祖先_leetcode 530 c++

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

题目列表

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

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

代码随想录地址：https://programmercarl.com/0530.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E7%BB%9D%E5%AF%B9%E5%B7%AE.html

题目

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

示例 1：

输入：root = [4,2,6,1,3]
输出：1
1
2

示例 2：

输入：root = [1,0,48,null,null,12,49]
输出：1
1
2

提示：

• 树中节点的数目范围是 [2, $10^4$]
• 0 <= Node.val <= $10^5$

**注意：**本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同

代码

递归代码

/*
 * @lc app=leetcode.cn id=530 lang=cpp
 *
 * [530] 二叉搜索树的最小绝对差
 */

// @lc code=start
/**
 * 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 traverse(TreeNode* node)
    {
        if(node == nullptr)
            return;
        //左
        traverse(node->left);
        //中
        if(pre != nullptr)
            res = min(res, node->val - pre->val);
        pre = node;//记录前一个元素
        //右
        traverse(node->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traverse(root);
        return res;
    }
};
// @lc code=end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

非递归代码-迭代代码

/*
 * @lc app=leetcode.cn id=530 lang=cpp
 *
 * [530] 二叉搜索树的最小绝对差
 */

// @lc code=start
/**
 * 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) {
        int res = INT_MAX;
        TreeNode* pre = nullptr;
        stack<TreeNode*> st;
        if(root != nullptr)
            st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();
            if(node == nullptr)
            {
                node = st.top();
                st.pop();
                if(pre != nullptr)
                    res = min(res, node->val - pre->val);
                pre = node;
            }
            else
            {
                if(node->right) st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if(node->left) st.push(node->left);
            }
        }
        return res;
    }
};
// @lc code=end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

501.二叉搜索树中的众数

代码随想录地址：https://programmercarl.com/0501.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E4%BC%97%E6%95%B0.html

题目

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

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

示例 1：

输入：root = [1,null,2,2]
输出：[2]
1
2

示例 2：

输入：root = [0]
输出：[0]
1
2

提示：

• 树中节点的数目在范围 [1, $10^4$] 内
• -$10^5$ <= Node.val <= $10^5$

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

代码

是写的递归的代码，非递归的就是一个中序遍历，然后对当前节点做一些处理，因此没写。

/*
 * @lc app=leetcode.cn id=501 lang=cpp
 *
 * [501] 二叉搜索树中的众数
 */

// @lc code=start
/**
 * 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 = INT_MIN;
    int count = 0;
    vector<int> res;
    TreeNode* pre = nullptr;
    void traverse(TreeNode* node)
    {
        if(node == nullptr)
            return;
        //左
        traverse(node->left);
        //中
        //当当前元素与前一个元素相等，则将count++
        if(pre != nullptr && node->val == pre->val)
            count++;
        //当当前元素与前一个元素不相等，则将count置为1
        if(pre == nullptr || node->val != pre->val)
            count = 1;
        pre = node;//记录前一个元素  
        //当count == maxcount时，要将当前节点入vector      
        if(maxcount == count)
            res.push_back(node->val);
        //当count > maxcount时，要将之前的节点清空并将当前节点存起来
        if(maxcount < count)
        {
            res.clear();
            res.push_back(node->val);
            maxcount = count;
        }
        traverse(node->right);
    }
public:
    vector<int> findMode(TreeNode* root) {
        maxcount = INT_MIN;
        count = 0;
        pre = nullptr;
        res.clear();
        traverse(root);
        return res;
    }
};
// @lc code=end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

代码随想录地址：https://programmercarl.com/0236.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88.html

题目

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

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

示例 1：

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

示例 2：

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

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1
1
2

提示：

• 树中节点数目在范围 [2, $10^5$] 内。
• -$10^9$ <= Node.val <= $10^9$
• 所有 Node.val 互不相同 。
• p != q
• p 和 q 均存在于给定的二叉树中。

整体思路

情况1

情况2

情况1的处理办法把情况2包括了，因为p和q一定存在。

代码

没有迭代法的解法，因为迭代法不适合回溯的过程。

/*
 * @lc app=leetcode.cn id=236 lang=cpp
 *
 * [236] 二叉树的最近公共祖先
 */

// @lc code=start
/**
 * 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) {
        //如果root为空，那么直接返回空
        if(root == nullptr)
            return root;
        //如果root等于p或q，那么返回root
        if(root == p || root == q)
            return root;
        //左
        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;
        else if(left == nullptr && right != nullptr)
            return right;
        else//如果左子树和右子树都为空
            return nullptr;
    }
};
// @lc code=end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41