代码随想录训练营第二十二天| ● 235. 二叉搜索树的最近公共祖先 ● 701.二叉搜索树中的插入操作 ● 450.删除二叉搜索树中的节点

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

题目链接/文章讲解：代码随想录

视频讲解：二叉搜索树找祖先就有点不一样了！| 235. 二叉搜索树的最近公共祖先_哔哩哔哩_bilibili

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);
    }
};

 这道题运用了搜索二叉树的性质，如果是搜索二叉树，从上到下第一个搜到的在p、q节点中间的值的节点就是p、q两节点的最近公共祖先，具体推导可以看代码随想录。代码的思想是使用递归做法,如果左右节点不为空，说明左右子树的节点的值在p、q的值中间，也就是两节点的最近公共祖先了，直接返回即可。

代码精简后如下：

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        } else if (root->val < p->val && root->val < q->val) {
            return lowestCommonAncestor(root->right, p, q);
        } else return root;
    }

迭代法也比较简单：

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;
    }

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

题目链接/文章讲解：代码随想录

视频讲解：原来这么简单？ | LeetCode：701.二叉搜索树中的插入操作_哔哩哔哩_bilibili

TreeNode* insertIntoBST(TreeNode* root, int val) {
        TreeNode* result = root;
        if (root == NULL) return new TreeNode(val);
        while (root) {
            if (val > root->val) {
                if (!root->right)
                    break;
                root = root->right;
            }
            if (val < root->val) {
                if (!root->left)
                    break;
                root = root->left;
            }
        }
        if (val > root->val) root->right = new TreeNode(val);
        else root->left = new TreeNode(val);
        return result;
    }

自己的代码，采用了迭代法，从上至下遍历整颗树，直至找到插入元素应该在末尾插入的位置将其插入。

TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if (root->val > val) root->left = insertIntoBST(root->left, val);
        if (root->val < val) root->right = insertIntoBST(root->right, val);
        return root;
    }

使用递归法可以，终止条件时，直接将该节点返回给上级即可直接完成插入操作。同时呢没改变root的值，最后直接返回root即可。

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

题目链接/文章讲解： 代码随想录

视频讲解：调整二叉树的结构最难！| LeetCode：450.删除二叉搜索树中的节点_哔哩哔哩_bilibili

TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == NULL) return NULL;
        if (root->val == key) {
            if (!root->left && !root->right) {
                delete root;
                return NULL;
            }
            if (root->left && !root->right) {
                TreeNode* node = root->left;
                delete root;
                return node;
            }
            if (!root->left && root->right) {
                TreeNode* node = root->right;
                delete root;
                return node;
            }
            if (root->left && root->right) {
                TreeNode* cur = root->right;
                while (cur->left) {
                    cur = cur->left;
                }
                cur->left = root->left;
            }
            TreeNode* node = root->right;
            delete root;
            return node;
        }

        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }

 搜索二叉树的删除节点，首先有以下几种情况，这也是解决这道题的关键：

• 第一种情况：没找到删除的节点，遍历到空节点直接返回了
• 找到删除的节点
  • 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
  • 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
  • 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
  • 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

根据这几种情况来进行代码的编写即可。

搜索二叉树时，如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？

搜索一条边的写法：

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

 搜索整个树写法：
 

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

本道题虽然不需要回溯，但最后要返回的是根节点，也是要搜索整个树，因此采用第二种写法。