代码随想录刷题第23天

最新推荐文章于 2024-08-15 05:02:54 发布

气氛组阿宇

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量66

点赞数

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/Bi11y/article/details/129040976

版权

代码随想录刷题第23天

修剪二叉搜索树


/*

* @lc app=leetcode.cn id=669 lang=cpp

*

* [669] 修剪二叉搜索树

*

* https://leetcode.cn/problems/trim-a-binary-search-tree/description/

*

* algorithms

* Medium (67.93%)

 * Likes:    756

* Dislikes: 0

 * Total Accepted:    110.5K

* Total Submissions: 162.6K

 * Testcase Example:  '[1,0,2]\n1\n2'

*

* 给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树

* 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。

* 

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

* 

* 

* 

* 示例 1：

* 

* 

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

* 输出：[1,null,2]

* 

* 

* 示例 2：

* 

* 

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

* 输出：[3,2,null,1]

* 

* 

* 

* 

* 提示：

* 

* 

* 树中节点数在范围 [1, 10^4] 内

* 0 <= Node.val <= 10^4

* 树中每个节点的值都是 唯一 的

* 题目数据保证输入是一棵有效的二叉搜索树

* 0 <= low <= high <= 10^4

* 

* 

*/

 

// @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) {}

* };

*/

#include<iostream>

#include <vector>

using namespace std;

 

//   struct TreeNode {

//       int val;

//       TreeNode *left;

//       TreeNode *right;

//       TreeNode(int x) : val(x), left(NULL), right(NULL) {}

//   };

 

class Solution {

public:

    TreeNode * traversal(TreeNode* root, int low, int high){

            if (!root)

            {

                return nullptr;

            }

            if (root->val < low)

            {

                TreeNode *right = traversal(root->right,low,high);

                return right;

            }

            if (root->val > high)

            {

                TreeNode *left = traversal(root->left,low,high);

                return left;

            }

            root->left = traversal(root->left,low,high);

            root->right = traversal(root->right,low,high);

 

            return root;

    }

    TreeNode* trimBST(TreeNode* root, int low, int high) {

        TreeNode *result = traversal(root,low,high);

        return result;

    }

};

// @lc code=end

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


/*

* @lc app=leetcode.cn id=108 lang=cpp

*

* [108] 将有序数组转换为二叉搜索树

*

* https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/

*

* algorithms

* Easy (77.32%)

 * Likes:    1233

* Dislikes: 0

 * Total Accepted:    329.5K

* Total Submissions: 426.1K

 * Testcase Example:  '[-10,-3,0,5,9]'

*

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

* 

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

* 

* 

* 

* 示例 1：

* 

* 

* 输入：nums = [-10,-3,0,5,9]

* 输出：[0,-3,9,-10,null,5]

* 解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

* 

* 

* 

* 示例 2：

* 

* 

* 输入：nums = [1,3]

* 输出：[3,1]

* 解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

* 

* 

* 

* 

* 提示：

* 

* 

* 1 <= nums.length <= 10^4

* -10^4 <= nums[i] <= 10^4

* nums 按 严格递增 顺序排列

* 

* 

*/

 

// @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) {}

* };

*/

#include<iostream>

#include <vector>

using namespace std;

 

//   struct TreeNode {

//       int val;

//       TreeNode *left;

//       TreeNode *right;

//       TreeNode(int x) : val(x), left(NULL), right(NULL) {}

//   };

 

class Solution {

public:

 

    TreeNode * traversal(vector<int>& nums,int left,int right){

        if(left > right) return nullptr;

        int mid = (right - left)/2 +left;

        TreeNode *node = new TreeNode(nums[mid]);

        node->left = traversal(nums,left,mid-1);

        node->right = traversal(nums,mid+1,right);

        return node;

    }

 

    TreeNode* sortedArrayToBST(vector<int>& nums) {

        int left = 0;

        int right = nums.size()-1;

        TreeNode *result = traversal(nums,left,right);

        return result;

    }

};

// @lc code=end

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


/*

* @lc app=leetcode.cn id=538 lang=cpp

*

* [538] 把二叉搜索树转换为累加树

*

* https://leetcode.cn/problems/convert-bst-to-greater-tree/description/

*

* algorithms

* Medium (75.89%)

 * Likes:    842

* Dislikes: 0

 * Total Accepted:    210.1K

* Total Submissions: 276.8K

 * Testcase Example:  '[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]'

*

* 给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（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]

* 

* 

* 示例 2：

* 

* 输入：root = [0,null,1]

* 输出：[1,null,1]

* 

* 

* 示例 3：

* 

* 输入：root = [1,0,2]

* 输出：[3,3,2]

* 

* 

* 示例 4：

* 

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

* 输出：[7,9,4,10]

* 

* 

* 

* 

* 提示：

* 

* 

* 树中的节点数介于 0 和 10^4^ 之间。

* 每个节点的值介于 -10^4 和 10^4 之间。

* 树中的所有值 互不相同 。

* 给定的树为二叉搜索树。

* 

* 

*/

 

// @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) {}

* };

*/

 

#include<iostream>

#include <vector>

using namespace std;

 

//   struct TreeNode {

//       int val;

//       TreeNode *left;

//       TreeNode *right;

//       TreeNode(int x) : val(x), left(NULL), right(NULL) {}

//   };

 

class Solution {

public:

    int pre = 0;

    void traversal(TreeNode* root){

        if(!root) return ;

        traversal(root->right);

        pre = pre + root->val;

        root->val = pre;

        traversal(root->left);

    }

    TreeNode* convertBST(TreeNode* root) {

        traversal(root);

        return root;

    }

};

// @lc code=end