今日刷题重点—二叉搜索树
文章目录
- 669. 修剪二叉搜索树
- 题目描述
- 示例 1：
- 示例 2：
- 示例 3：
- 示例 4：
- 示例 5：
- 思路分析
- 方法一:递归
- 参考代码1
- 方法二:迭代
- 参考代码2
- 108. 将有序数组转换为二叉搜索树
- 题目描述
- 示例 1：
- 示例二
- 思路分析
- 参考代码
- 538. 把二叉搜索树转换为累加树
- 题目描述
- 示例一:
- 示例 2：
- 示例 3：
- 示例 4：
- 思路分析
- 参考代码
669. 修剪二叉搜索树
题目描述
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树不应该改变保留在树中的元素的相对结构（即，如果没有被移除，原有的父代子代关系都应当保留）。 可以证明，存在唯一的答案。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。
示例 1：
示例 2：
输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]
输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]
示例 3：
输入：root = [1], low = 1, high = 2
输出：[1]
示例 4：
输入：root = [1,null,2], low = 1, high = 3
输出：[1,null,2]
示例 5：
输入：root = [1,null,2], low = 2, high = 4
输出：[2]
思路分析
直接的想法就是递归处理,然后遇到 root->val < low || root->val > high 直接返回NULL.
然而当节点不满足时,还要考虑节点的左右子树是否满足.
如图所示:[1,3]区间对应二叉搜索树还要包括0节点的右子树.即使0节点不满足.
我们发现节点0并不符合区间要求，那么将节点0的右孩子 节点2 直接赋给 节点3的左孩子就可以了（就是把节点0从二叉树中移除），然后再递归判断右孩子是否满足.
方法一:递归
递归三部曲:
- 参数和返回值:参数为要递归的根节点以及low,high俩值. 返回值为满足条件的子树的根节点.
- 结束条件:当节点为NULL时,结束递归.
- 单层递归逻辑:如果当前节点在指定范围以左,则向root节点的右子树进行递归; 如果当前节点在指定范围以右,则向root节点的左子树进行递归;如果当前节点在指定范围内则继续向左向右递归,更新其左右子树.
参考代码1
//递归法
TreeNode* trimBST(TreeNode* root, int low, int high) {
if(root==nullptr) { //遇到空节点就直接返回NULL
return nullptr;
}
//判断当前节点是否在指定范围内
if(root->val < low) { //如果root在指定范围以左,则向子树的右边进行递归遍历.
TreeNode* right = trimBST(root->right,low,high);
return right;
}
if(root->val > high) { //如果root在指定范围以右,则向子树左边进行递归遍历.
TreeNode* left = trimBST(root->left,low,high);
return left;
}
//如果当前root值在 指定范围内,则开始进行左递归,右递归 判断其左右子节点是否符合
root->left = trimBST(root->left,low,high);
root->right = trimBST(root->right,low,high);
return root;//返回构成的新树的根节点
}
方法二:迭代
1.先处理头结点,让其在 指定范围内
2.处理root的左孩子
3.处理root的右孩子
参考代码2
//迭代法
TreeNode* trimBST(TreeNode* root,int low,int high) {
if(root==nullptr) {
return nullptr;
}
//处理头结点,让头结点在 指定范围内
while(root!=NULL&&(root->val < low || root->val > high)) {
if(root->val < low) { //小于low则向左走
root = root->right;
} else { //大于high则向左走
root = root->left;
}
}
TreeNode* cur = root;
//处理root的左孩子
while(cur) {
while(cur->left &&cur->left->val < low) {//这里的结束条件为节点为NULL
cur->left = cur->left->right;//虽然cur->left不满足,但是cur->left->right右边的比cur->left大,也许会有满足的.
}
cur = cur->left;//如果在 指定范围 内,则继续向左寻找满足条件的节点
}
cur = root;
//处理root的右孩子(原理相同)
while(cur) {
while(cur->right && cur->right->val > high ){
cur->right = cur->right->left;//虽然cur->right不满足,但是cur->right->left左边的比cur->right小,也许会有满足的.
}
cur = cur->right;//如果在 指定范围 内,则继续向右寻找满足条件的节点
}
return root;
}
108. 将有序数组转换为二叉搜索树
题目描述
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
示例 1：
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
示例二
输入：nums = [1,3]
输出：[3,1]
解释：[1,3] 和 [3,1] 都是高度平衡二叉搜索树。
思路分析
寻找分割点，分割点作为当前节点，然后递归左区间和右区间。
由于是有序的,所以只要从分割点是中间节点,那么构成的树就是平衡的.
递归三要素:
- 参数和返回值:参数为需要递归的数组以及左右边界,返回值为新构成子树的根节点
- 结束条件:由于是左闭右闭合的,所以如果left > right则返回.
- 单层递归逻辑:确定分割点,以分割点创建根节点,之后构建左子树,构建右子树.
参考代码
//方法一:递归.
TreeNode* traversal(vector<int>& nums,int left,int right) {
if(left > right) {
return NULL;
}
int mid = left + (right-mid)/2;
TreeNode* root = new TreeNode(nums[mid]);//构建根节点
root->left = traversal(nums,left,mid-1);//构建左子树
root->right = traversal(nums,mid+1,right);//构建右子树
return root; //返回根节点
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
return traversal(nums,0,nums.size()-1);
}
538. 把二叉搜索树转换为累加树
题目描述
给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：
节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。
示例一:
输入：[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]
思路分析
二叉搜索树中序遍历时,数字是从小到大,由于我们需要的是从大到小进行累加,所以遍历顺序为:右中左. 然后在遍历的时候进行累加即可.
参考代码
//递归法
TreeNode* pre;
void traversal(TreeNode* root) {
if(root==NULL){
return;
}
traversal(root->right);//遍历右边
if(pre!=NULL){//中
root->val += pre->val;
}
pre = root;
traversal(root->left);//遍历左边
}
TreeNode* convertBST(TreeNode* root){
traversal(root);
return root;
}
