【数据结构/二叉搜索树/修改与改造】题解+详细备注(共8题)
class Solution {
public:
TreeNode* recursive(TreeNode* root, int val){
if(!root){
TreeNode* node = new TreeNode(val);
return node;
}
if(root->val > val) root->left = recursive(root->left,val);
if(root->val < val) root->right = recursive(root->right,val);
return root;
}
TreeNode* insertIntoBST(TreeNode* root, int val) {
if(!root){
TreeNode* node = new TreeNode(val);
return node;
}
TreeNode* cur = root;
TreeNode* pre = root;
while(cur != nullptr){
pre = cur;
if(cur->val > val) cur = cur->left;
else cur = cur->right;
}
TreeNode* node = new TreeNode(val);
if(pre->val > val) pre->left = node;
else pre->right = node;
return root;
}
};
class Solution {
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if(!root) return {};
if(root->val == key){
if(!root->left && !root->right) return {};
else if(!root->right) return root->left;
else if(!root->left) return root->right;
else{
TreeNode* left = root->left;
TreeNode* right = root->right;
while(right->left){
right = right->left;
}
right->left = left;
return root->right;
}
}
if(root->val > key) root->left = deleteNode(root->left,key);
if(root->val < key) root->right = deleteNode(root->right,key);
return root;
}
};
class Solution {
public:
TreeNode* trimBST(TreeNode* root, int low, int high) {
if(!root) return{};
while(root && (root->val < low || root->val > high)){
if(root->val > high) root = root->left;
else root = root->right;
}
TreeNode* cur = root;
while(cur){
while(cur->left && (cur->left->val < low)){
cur->left = cur->left->right;
}
cur = cur->left;
}
cur = root;
while(cur){
while(cur->right && (cur->right->val > high)){
cur->right = cur->right->left;
}
cur = cur->right;
}
return root;
}
};
class Solution {
public:
TreeNode* recursive(vector<int> &num,int left,int right){
if(left > right) return{};
int mid = (right + left)/2;
TreeNode* root = new TreeNode(num[mid]);
root->left = recursive(num,left,mid-1);
root->right = recursive(num,mid+1,right);
return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
TreeNode *root = recursive(nums,0,nums.size()-1);
return root;
}
};
class Solution {
private:
vector<int> vec;
void traversal(TreeNode* cur) {
if (cur == nullptr) {
return;
}
traversal(cur->left);
vec.push_back(cur->val);
traversal(cur->right);
}
TreeNode* getTree(vector<int>& nums, int left, int right) {
if (left > right) return nullptr;
int mid = left + ((right - left) / 2);
TreeNode* root = new TreeNode(nums[mid]);
root->left = getTree(nums, left, mid - 1);
root->right = getTree(nums, mid + 1, right);
return root;
}
public:
TreeNode* balanceBST(TreeNode* root) {
traversal(root);
return getTree(vec, 0, vec.size() - 1);
}
};
class Solution {
public:
void inorder(TreeNode* root){
if(!root) return;
inorder(root->left);
v.push_back(root->val);
inorder(root->right);
}
int kthSmallest(TreeNode* root, int k) {
if(!root) return -1;
inorder(root);
return v[k-1];
}
public:
vector<int> v;
};
class BSTIterator {
public:
int curIndex{};
vector<int> v;
public:
void inorder(TreeNode* root){
if(!root) return;
inorder(root->left);
v.emplace_back(root->val);
inorder(root->right);
}
BSTIterator(TreeNode* root) {
inorder(root);
}
int next() {
return v[curIndex++];
}
bool hasNext() {
if(curIndex < v.size()) return true;
else return false;
}
};