方法:递归
class Solution {
private:
TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
if (cur == NULL) return cur;
if (cur->val > p->val && cur->val > q->val) {
TreeNode* left = traversal(cur->left, p, q);
if (left != NULL) return left;
}
if (cur->val < p->val && cur->val < q->val) {
TreeNode* right = traversal(cur->right, p, q);
if (right != NULL) return right;
}
return cur;
}
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
return traversal(root, p, q);
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
while (root) {
if (root->val > p->val && root->val > q->val) {
root = root->left;
} else if (root->val < p->val && root->val < q->val){
root = root->right;
} else return root;
}
return NULL;
}
};
$时间复杂度O(n),空间复杂度O(1)
方法:递归
class Solution {
private:
TreeNode* parent;
void traversal(TreeNode* cur, int val) {
if (cur == NULL) {
TreeNode* nod = new TreeNode(val);
if (parent->val > val) parent->left = nod;
else parent->right = nod;
return ;
}
parent = cur;
if (cur->val > val) traversal(cur->left, val);
if (cur->val < val) traversal(cur->right, val);
return ;
}
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
parent = new TreeNode(0);
if (root ==NULL) {
root = new TreeNode(val);
}
traversal(root, val);
return root;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
class Solution {
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
if (root == NULL) {
root = new TreeNode(val);
return root;
}
TreeNode* cur = root;
TreeNode* perent = root;
while (cur != NULL) {
perent = cur;
if (cur->val > val) cur = cur->left;
else cur = cur->right;
}
TreeNode* nod = new TreeNode(val);
if (perent->val > val) perent->left = nod;
else perent->right = nod;
return root;
}
};
$时间复杂度O(n),空间复杂度O(1)
方法:递归
class Solution {
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if (root == NULL) return root;
if (root->val == key) {
if (root->left == NULL && root->right == NULL) {
delete root;
return NULL;
}
else if (root->left == NULL) {
auto retNode = root->right;
delete root;
return retNode;
}
else if (root->right == NULL) {
auto retNode = root->left;
delete root;
return retNode;
}
else {
TreeNode* cur = root->right;
while (cur->left != nullptr) {
cur = cur->left;
}
cur->left = root->left;
TreeNode* tmp = root;
root = root->right;
delete tmp;
return root;
}
}
if (root->val > key) root->left = deleteNode(root->left, key);
if (root->val < key) root->right = deleteNode(root->right, key);
return root;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
class Solution {
private:
TreeNode* deleteOnedNode(TreeNode* target) {
if (target == NULL) return target;
if (target->right == NULL) return target->left;
TreeNode* cur = target->right;
while (cur->left != NULL) {
cur = cur->left;
}
cur->left = target->left;
return target->right;
}
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if (root == NULL) return root;
TreeNode* cur = root;
TreeNode* pre = nullptr;
while (cur) {
if (cur->val == key) break;
pre = cur;
if (cur->val > key) cur = cur->left;
else cur = cur->right;
}
if (pre == nullptr) return deleteOnedNode(cur);
if (pre->left && pre->left->val == key) pre->left = deleteOnedNode(cur);
if (pre->right && pre->right->val == key) pre->right = deleteOnedNode(cur);
return root;
}
};
$时间复杂度O(n),空间复杂度O(1)