代码随想录-二叉搜索树②-CSDN博客

本文链接：https://blog.csdn.net/weixin_42373086/article/details/140369643

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

题目描述：

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

输入输出示例：

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

思路和想法：

根据二叉搜索树的特点，一共有三种情况：

（1）p, q分别在根节点的左子树和右子树上，这样它们的最近公共祖先就为根节点

（2）p、q都在左子树则一直根节点左遍历即可，遇到（1）返回根节点，未遇到（1），则返回其中一个节点

（3）p、q都在右子树则一直根节点右遍历即可，遇到（1）返回根节点，未遇到（1），则返回其中一个节点

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL || root == p || root == q) return root;

        TreeNode* left;
        TreeNode* right;
        if(p->val < root->val && q->val < root->val){            //左
            left = lowestCommonAncestor(root->left, p, q);
            if(left != NULL){
                return left;
            }
        } 

        if(p->val > root->val && q->val > root->val) {          //右
            right = lowestCommonAncestor(root->right, p, q);
            if(right != NULL){
                return right;
            }
        }

        return root;                                           //中
    }
};

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

题目描述：

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回 任意有效的结果 。

输入输出示例：

示例 1：

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

提示：

树中的节点数将在 [0, 104]的范围内。
-108 <= Node.val <= 108
所有值 Node.val 是 独一无二 的。
-108 <= val <= 108
保证 val 在原始BST中不存在。

思路和想法：

这道题采用前序遍历的方式，之后把这个节点放到叶子节点。

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr) {
            TreeNode* node = new TreeNode(val);
            return node;
        }

        if(val < root->val) root->left = insertIntoBST(root->left, val);  //左

        if(val > root->val) root->right = insertIntoBST(root->right, val);//右

        return root;
    }
};

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

题目描述：

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。

输入输出示例：

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0
输出: []

提示:

节点数的范围 [0, 104].
-105 <= Node.val <= 105
节点值唯一
root 是合法的二叉搜索树
-105 <= key <= 105

思路和想法：

分析会出现的情况：

（1）没找到要删除的节点

（2）删除的是叶子节点

（3）删除的节点，左孩子不为空，右孩子为空，让删除节点的父节点直接指到其的子节点

（4）删除的节点，左孩子为空，右孩子不为空，让删除节点的父节点直接指到其的子节点

（5）删除的节点，左右孩子都不为空。----对删除节点的左子树怎么安置，放到删除节点的右子树的最左的叶节点上面，并且删除节点的父节点直接指到其的子节点

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        //第一种情况,遍历到空，未找到删除的节点
        if(root == nullptr) return root;
        
        if(root->val == key){
            //第二种情况,叶节点
            if(root->left == nullptr && root->right == nullptr) return nullptr;
            //第三种情况，左不空右空
            else if(root->left != nullptr && root->right == nullptr) return root->left;
            //第四种情况，左空右不空
            else if(root->left == nullptr && root->right != nullptr) return root->right;

            //第五种情况，左不空右不空
            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;            
    }
};

669. 修剪二叉搜索树

题目描述：

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在 唯一的答案 。

所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

输入输出示例：

示例 1：

输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]

示例 2：

输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]

提示：

树中节点数在范围 [1, 104] 内
0 <= Node.val <= 104
树中每个节点的值都是唯一的
题目数据保证输入是一棵有效的二叉搜索树
0 <= low <= high <= 104

思路和想法：

核心思路是遍历，看节点是否是小于low或者高于high，小于low的节点左子树删除，高于high的节点右子树删除。

注：这里需要注意的就是，小于low的节点右子树（还是有概率在区间内的）需要继续遍历，高于high的节点的左子树（还是有概率在区间内的）需要继续遍历。

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        TreeNode* right;
        TreeNode* left;
        if(root == nullptr) return root;
        
        if(root->val < low){
            right = trimBST(root->right, low, high);
            return right;
        }
        if(root->val >high){
            left = trimBST(root->left, low, high);
            return left;
        }

        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

108.将有序数组转换为二叉搜索树

题目描述：

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵平衡二叉搜索树。

输入输出示例：

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 按 严格递增 顺序排列

思路和想法：

采用中序数组（有序）来构建平衡二叉搜索树。寻找中间节点（二分法），分成左区间和右区间。

class Solution {
private:
    TreeNode* travserl(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 =travserl(nums, left, mid - 1);      //递归左子树
        root->right = travserl(nums, mid + 1, right);   //递归右子树
        return root;        
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int left = 0;
        int right = nums.size() - 1;
        TreeNode* root = travserl(nums, left, right); 
        return root;
    }
};

538.把二叉搜索树转换为累加树

题目描述：

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。
节点的右子树仅包含键大于节点键的节点。
左右子树也必须是二叉搜索树。

注意：本题和 1038: . - 力扣（LeetCode）相同

输入输出示例：

示例 1：

输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

示例 2：

输入：root = [0,null,1]
输出：[1,null,1]

示例 3：

输入：root = [1,0,2]
输出：[3,3,2]

示例 4：

输入：root = [3,2,4,1]
输出：[7,9,4,10]

提示：

树中的节点数介于 0 和 104 之间。
每个节点的值介于 -104 和 104 之间。
树中的所有值 互不相同 。
给定的树为二叉搜索树。

思路和想法：

一直右遍历，遍历到最右的节点，从它开始不断加和自身node.val，右中左---反中序遍历。

class Solution {
    int pre = 0; // 记录前一个节点的数值
void traversal(TreeNode* cur){
    if(cur == nullptr) return;
    traversal(cur->right);          //右
    cur->val += pre;                //中
    pre = cur->val;
    traversal(cur->left);           //左
}
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;    
        traversal(root);
        return root;   
    }
};