代码随想录第20天： 235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作 、 450.删除二叉搜索树中的节点

 235. 二叉搜索树的最近公共祖先：利用好二叉搜索树的特点，理解从上向下去递归遍历，第一次遇到 cur节点是数值在[q, p]区间中，那么cur就是 q和p的最近公共祖先这一点。

// 236. 二叉树的最近公共祖先

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

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

int main()
{
    TreeNode *t2 = new TreeNode(6);
    t2->left = new TreeNode(2);
    t2->left->left = new TreeNode(0);
    t2->left->right = new TreeNode(4);
    t2->left->right->left = new TreeNode(3);
    t2->left->right->right = new TreeNode(5);

    t2->right = new TreeNode(8);
    t2->right->left = new TreeNode(7);
    t2->right->right = new TreeNode(9);

    TreeNode *res = lowestCommonAncestor(t2, 2, 8);
    cout << res->val << endl;

    return 0;
}

701.二叉搜索树中的插入操作 ：一样利用好二叉搜索树的特性即可

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

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 需要一个全局变量来存放之前的节点
TreeNode *parent;
void traversal(TreeNode *cur, int val)
{
    if (cur == NULL)
    {
        TreeNode *node = new TreeNode(val);
        if (val > parent->val)
            parent->right = node;
        else
            parent->left = node;
        return;
    }
    parent = cur;
    if (cur->val > val)
        traversal(cur->left, val);
    if (cur->val < val)
        traversal(cur->right, val);
    return;
}

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

void printPreorder(TreeNode *node)
{
    if (node == nullptr)
    {
        return; // 如果节点为空，则返回
    }

    std::cout << node->val << " "; // 首先打印根节点的值
    printPreorder(node->left);     // 递归打印左子树
    printPreorder(node->right);    // 递归打印右子树
}

int main()
{
    TreeNode *t2 = new TreeNode(4);
    t2->left = new TreeNode(2);
    t2->left->left = new TreeNode(1);
    t2->left->right = new TreeNode(3);
    t2->right = new TreeNode(7);

    TreeNode *res = insertIntoBST(t2, 5);
    printPreorder(res);

    return 0;
}

 450.删除二叉搜索树中的节点：代码如下，需要注意的是第五种情况

// 450.删除二叉搜索树中的节点，注意第五种情况，很容易忽略
#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode *deleteNode(TreeNode *root, int key)
{
    if (root == nullptr)
        return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
    if (root->val == key)
    {
        // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
        if (root->left == nullptr && root->right == nullptr)
        {
            ///! 内存释放
            delete root;
            return nullptr;
        }
        // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
        else if (root->left == nullptr)
        {
            auto retNode = root->right;
            ///! 内存释放
            delete root;
            return retNode;
        }
        // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
        else if (root->right == nullptr)
        {
            auto retNode = root->left;
            ///! 内存释放
            delete root;
            return retNode;
        }
        // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
        // 并返回删除节点右孩子为新的根节点。
        else
        {
            TreeNode *cur = root->right; // 找右子树最左面的节点
            while (cur->left != nullptr)
            {
                cur = cur->left;
            }
            cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
            TreeNode *tmp = root;   // 把root节点保存一下，下面来删除
            root = root->right;     // 返回旧root的右孩子作为新root
            delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
            return root;
        }
    }
    if (root->val > key)
        root->left = deleteNode(root->left, key);
    if (root->val < key)
        root->right = deleteNode(root->right, key);
    return root;
}

void printPreorder(TreeNode *node)
{
    if (node == nullptr)
    {
        return; // 如果节点为空，则返回
    }

    std::cout << node->val << " "; // 首先打印根节点的值
    printPreorder(node->left);     // 递归打印左子树
    printPreorder(node->right);    // 递归打印右子树
}

int main()
{
    TreeNode *t2 = new TreeNode(5);
    t2->left = new TreeNode(3);
    t2->left->left = new TreeNode(2);
    t2->left->right = new TreeNode(4);
    t2->right = new TreeNode(6);
    t2->right->right = new TreeNode(7);

    TreeNode *res = deleteNode(t2, 3);
    printPreorder(res);

    return 0;
}