LeetCode题解二叉树（十四）：669 修改二叉搜索树；108 将有序数组转换为二叉搜索树；538 把二叉搜索树转换为累加树

news2024/11/19 5:50:11

二叉树

669 修改二叉搜索树 medium

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

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

题中已经提到，不可以修改树中元素的相对结构，所以此前通过移动二叉树某部分的方法在此题中不适用。

首先要找到结点数值在[low, high]之间的值要删除的结点，这个点就是我们最终要返回的根节点。而难处理的点无非两种情况：

值比Low小，但有比它值大的右子树，
值比High大，但有比它值小的左子树

这两种情况下，就需要做处理，让子树直接替换被删除结点的位置就可以了

所以，按照这个处理逻辑，我们先来用迭代法解决这道题，代码如下：

TreeNode* trimBST(TreeNode* root, int low, int high) {
    if (root == nullptr) return nullptr;

    while (root != nullptr && (root->val < low || root->val > high)) {
        if (root->val < low) {
            root = root->right;
        } else root = root->left;
    }

    TreeNode* cur = root;
    while (cur != nullptr) {
        while (cur->left != nullptr && cur->left->val < low)
            cur->left = cur->left->right;
        cur = cur->left;
    }
    cur = root;
    while (cur != nullptr) {
        while (cur->right != nullptr && cur->right->val > high)
            cur->right = cur->right->left;
        cur = cur->right;
    }

    return root;
}

而如果使用递归法，思路也是一样的，会更简洁一些，此处借鉴随想录中的代码：

TreeNode* trimBST(TreeNode* root, int low, int high) {
    if (root == nullptr ) return nullptr;
    if (root->val < low) {
        TreeNode* right = trimBST(root->right, low, high); // 寻找符合区间[low, high]的节点
        return right;
    }
    if (root->val > high) {
        TreeNode* left = trimBST(root->left, low, high); // 寻找符合区间[low, high]的节点
        return left;
    }
    root->left = trimBST(root->left, low, high); // root->left接入符合条件的左孩子
    root->right = trimBST(root->right, low, high); // root->right接入符合条件的右孩子
    return root;
}

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

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

高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

此前有过根据后序/前序 + 中序构造二叉树的题目，

也有过将二叉搜索树转换为数组解决问题的题目

如果要构造高度平衡的二叉搜索树，必然要从中间结点出发，划分分割点，然后逐步递归寻找分割点。

递归法的返回类型为结点，传入参数要有原数组和分割后的数组边界

终止条件即分割数组中没有值

单次递归的遍历逻辑有，先找到中间结点，然后分割区间，用于构建当前结点的左右子树，整体代码如下：

TreeNode* reversal(vector<int>& nums, int left, int right) {
    if (left > right) return nullptr;
    int mid = (left + right) >> 1;
    TreeNode* root = new TreeNode(nums[mid]);
    root->left = reversal(nums, left, mid - 1);
    root->right = reversal(nums, mid + 1, right);

    return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
    TreeNode* root = reversal(nums, 0 ,nums.size() - 1);
    return root;
}

而迭代法则较为复杂一点，因为要构造三个序列存放遍历的结点，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标，代码借鉴代码随想录，如下所示：

TreeNode* sortedArrayToBST(vector<int>& nums) {
    if (nums.size() == 0) return nullptr;

    TreeNode* root = new TreeNode(0);   // 初始根节点
    queue<TreeNode*> nodeQue;           // 放遍历的节点
    queue<int> leftQue;                 // 保存左区间下标
    queue<int> rightQue;                // 保存右区间下标
    nodeQue.push(root);                 // 根节点入队列
    leftQue.push(0);                    // 0为左区间下标初始位置
    rightQue.push(nums.size() - 1);     // nums.size() - 1为右区间下标初始位置

    while (!nodeQue.empty()) {
        TreeNode* curNode = nodeQue.front();
        nodeQue.pop();
        int left = leftQue.front(); leftQue.pop();
        int right = rightQue.front(); rightQue.pop();
        int mid = left + ((right - left) / 2);

        curNode->val = nums[mid];       // 将mid对应的元素给中间节点

        if (left <= mid - 1) {          // 处理左区间
            curNode->left = new TreeNode(0);
            nodeQue.push(curNode->left);
            leftQue.push(left);
            rightQue.push(mid - 1);
        }

        if (right >= mid + 1) {         // 处理右区间
            curNode->right = new TreeNode(0);
            nodeQue.push(curNode->right);
            leftQue.push(mid + 1);
            rightQue.push(right);
        }
    }
    return root;
}

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

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

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

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

根据示例图可以看出来，遍历顺序应该是从右到左，即反中序遍历（右中左），记录前一个结点的值，然后累加当前结点的值即可。

返回类型为空，因为最终要返回根结点，遇到空结点返回；单层处理逻辑是，先往右遍历，然后当前结点先加上上一个结点的值，上个结点更替为当前结点，然后再往左遍历。

代码如下：

int pre = 0;
void reversal(TreeNode* cur) {
    if (cur == nullptr) return;
    reversal(cur->right);
    cur->val += pre;
    pre = cur->val;
    reversal(cur->left);
}

TreeNode* convertBST(TreeNode* root) {
    if (root == nullptr) return nullptr;
    reversal(root);
    return root;
}

而如果使用迭代法，直接使用中序遍历就好，此处参考代码随想录：

private:
    int pre; // 记录前一个节点的数值
    void traversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->right;   // 右
            } else {
                cur = st.top();     // 中
                st.pop();
                cur->val += pre;
                pre = cur->val;
                cur = cur->left;    // 左
            }
        }
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }