Day.17 | 235.二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点

235.二叉搜索树的最近公共祖先

要点：当节点遍历到p和q中间的时候，就是最近公共祖先。所以当p q都比当前遍历节点小，向左遍历，反之向右遍历，在中间，就是想要的结果。因为二叉搜索树有序的特性，此题相当于找公共祖先的特解。

class Solution {
public:
    TreeNode* traversal(TreeNode* node, TreeNode* p, TreeNode* q) {
        if (node == nullptr)
            return nullptr;
        if (node->val > p->val && node->val > q->val) {
            TreeNode* left = traversal(node->left, p, q);
            if (left)
                return left;
        }
        if (node->val < p->val && node->val < q->val) {
            TreeNode* right = traversal(node->right, p, q);
            if (right)
                return right;
        }
        return node;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root, p, q);
    }
};

701.二叉搜索树中的插入操作

要点：直接按二叉搜索树的规则插入节点，要插入的节点值比当前节点大，就往右边插，反之，往左边插（题中已经明说数值不会重复）。递归函数如果有返回值，就好处理一点，如果没有返回值，就需要一个额外的变量记录下上一个遍历的节点，用于判断最终是插入成左节点还是右节点。

class Solution {
public:
    TreeNode* traversal(TreeNode* node, int val) {
        if (node == nullptr) {
            node = new TreeNode(val);
            return node;
        }
        if (node->val > val) {
            node->left = traversal(node->left, val);
        }
        if (node->val < val) {
            node->right = traversal(node->right, val);
        }
        return node;
    }

    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == nullptr) return new TreeNode(val);
        return traversal(root, val);
    }
};

450.删除二叉搜索树中的节点

要点：有点复杂，五种情况要讨论清楚，没找到 找到了（左空右空 左不空右空 左空右不空 左不空右不空），当左不空右不空时，删除当前节点，直接接上右子树，然后把左子树接到右子树的最左边即可。

（对于二叉搜索树来说，节点的右子树的最左边是整个右子树的最小值，一定比其左子树的根节点大，把左子树接到右子树的最左边节点，不需要做任何额外判断即可保证二叉搜索树的有序性）

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr)
            return nullptr;
        if (root->val == key) {
            if (root->left == nullptr && root->right == nullptr) {
                delete root;
                return nullptr;
            } else if (root->left != nullptr && root->right == nullptr) {
                TreeNode* reNode = root->left;
                delete root;
                return reNode;
            } else if (root->left == nullptr && root->right != nullptr) {
                TreeNode* reNode = root->right;
                delete root;
                return reNode;
            } else {
                TreeNode* cur = root->right;
                while (cur->left != nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left;
                TreeNode* reNode = root->right;
                delete root;
                return reNode;
            }
        }
        if (root->val > key)
            root->left = deleteNode(root->left, key);
        if (root->val < key)
            root->right = deleteNode(root->right, key);
        return root;
    }
};