weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

_20LeetCode代码随想录算法训练营第二十天-C++二叉树 | 669.修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树

作者：weixin_40725706 | 2024-08-01 03:44:03

踩

题目列表

669.修剪二叉搜索树
108.将有序数组转换为二叉搜索树
538.把二叉搜索树转换为累加树
总结篇

669.修剪二叉搜索树

代码随想录地址：https://programmercarl.com/0669.%E4%BF%AE%E5%89%AA%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html

题目

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在 唯一的答案 。

所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

示例 1：

在这里插入图片描述

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

示例 2：

在这里插入图片描述

输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]
1
2

提示：

树中节点数在范围 [1, $10^4$ ]内
0 <= Node.val <= $10^4$
树中每个节点的值都是唯一的
题目数据保证输入是一棵有效的二叉搜索树
0 <= low <= high <= $10^4$

代码

写的递归代码，因为迭代代码不存在特别清晰的思路，因此没写。

/*
 * @lc app=leetcode.cn id=669 lang=cpp
 *
 * [669] 修剪二叉搜索树
 */

// @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:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root == nullptr)
            return nullptr;
        if(root->val < low)//为什么不直接返回右子树，因为右子树的左子树有可能不满足要求，需要判断，所以递归
            return trimBST(root->right, low, high);
        if(root->val > high)//为什么不直接返回左子树，因为左子树的右子树可能不满足要求，需要判断，所以递归
            return trimBST(root->left, low, high);
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};
// @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

108.将有序数组转换为二叉搜索树

代码随想录地址：

https://programmercarl.com/0108.%E5%B0%86%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E8%BD%AC%E6%8D%A2%E4%B8%BA%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html#%E9%80%92%E5%BD%92

题目

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：
在这里插入图片描述

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
1
2
3

在这里插入图片描述

示例 2：
在这里插入图片描述

输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。
1
2
3

提示：

1 <= nums.length <= $10^4$
- $10^4$ <= nums[i] <= $10^4$
nums 按 严格递增 顺序排列

整体思路

就是将中间节点作为头节点开始构建二叉树。

代码

递归代码

/*
 * @lc app=leetcode.cn id=108 lang=cpp
 *
 * [108] 将有序数组转换为二叉搜索树
 */

// @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:
    //变量left和right表示构建二叉树的元素在数组中的范围
    //使用的是[left, right]前闭后闭区间
    TreeNode* traverse(vector<int>& nums, int left, int right)
    {
        if(left > right)
            return nullptr;
        int mid = left + ((right - left)/2);//这样写是为了防止溢出int
        //构造根节点
        TreeNode* node = new TreeNode(nums[mid]);
        //构造根节点的左孩子
        node->left = traverse(nums, left, mid - 1);
        //构造根节点的右孩子
        node->right = traverse(nums, mid + 1, right);
        //返回根节点
        return node;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traverse(nums, 0, nums.size() - 1);
    }
};
// @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=108 lang=cpp
 *
 * [108] 将有序数组转换为二叉搜索树
 */

// @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:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        //迭代写法，就是实现递归的步骤
        //为什么使用队列而不用栈，因为本题的思路先进先出还是先进后出不影响结果
        //nodeQue每次入队的是元素0
        if(nums.size() == 0)
            return nullptr;
        //这个队列存储现场
        queue<TreeNode*> nodeQue;
        queue<int> leftQue;
        queue<int> rightQue;
        TreeNode* root = new TreeNode(0);
        //类似于保存现场
        nodeQue.push(root);//将根节点入栈
        leftQue.push(0);
        rightQue.push(nums.size() - 1);
        while(!nodeQue.empty())
        {
            //处理节点
            TreeNode* node = nodeQue.front();
            nodeQue.pop();
            int left = leftQue.front();
            leftQue.pop();
            int right = rightQue.front();
            rightQue.pop();
            int mid = left + (right - left)/2;
            //其实就是这里需要知道地址
            //这个地址就按顺序存在队列中
            node->val = nums[mid];
            //处理左边的节点
            if(left <= mid - 1)
            {
                node->left = new TreeNode(0);
                nodeQue.push(node->left);
                leftQue.push(left);
                rightQue.push(mid - 1);
            }
            //处理右边的节点
            if(right >= mid + 1)
            {
                node->right = new TreeNode(0);
                nodeQue.push(node->right);
                leftQue.push(mid + 1);
                rightQue.push(right);
            }
        }
        return root;
    }
};
// @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
62
63
64
65
66
67
68
69

538.把二叉搜索树转换为累加树

代码随想录地址：https://programmercarl.com/0538.%E6%8A%8A%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E8%BD%AC%E6%8D%A2%E4%B8%BA%E7%B4%AF%E5%8A%A0%E6%A0%91.html

题目

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。
节点的右子树仅包含键大于节点键的节点。
左右子树也必须是二叉搜索树。

**注意：**本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 相同

示例 1：

输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
1
2

示例 2：

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

示例 3：

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

示例 4：

输入：root = [3,2,4,1]
输出：[7,9,4,10]
1
2

提示：

树中的节点数介于 0 和 $10^4$ 之间。
每个节点的值介于 $10^4$ 和 &10^4$ 之间。
树中的所有值 互不相同 。
给定的树为二叉搜索树。

整体思路

就是右中左的遍历顺序。

代码

递归代码

/*
 * @lc app=leetcode.cn id=538 lang=cpp
 *
 * [538] 把二叉搜索树转换为累加树
 */

// @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 pre;
    void traverse(TreeNode* node)
    {
        if(node == nullptr)
            return;
        traverse(node->right);//右
        //中
        node->val += pre;
        pre = node->val;
        //左
        traverse(node->left);
        return;
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traverse(root);
        return root;
    }
};
// @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

迭代代码

/*
 * @lc app=leetcode.cn id=538 lang=cpp
 *
 * [538] 把二叉搜索树转换为累加树
 */

// @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:
    TreeNode* convertBST(TreeNode* root) {
        if(root == nullptr)
            return root;
        stack<TreeNode*> st;
        int pre = 0;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();
            if(node == nullptr)
            {
                node = st.top();
                st.pop();
                node->val += pre;
                pre = node->val;
            }
            else
            {
                if(node->left) st.push(node->left);
                st.push(node);
                st.push(nullptr);
                if(node->right) st.push(node->right);
            }
        }
        return root;
    }
};
// @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

总结篇

代码随想录地址：

https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E6%80%BB%E7%BB%93%E7%AF%87.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/912173