二叉树：leetcode 699.修建二叉搜索树、108.将有序数组转化为二叉搜索树、538.把二叉搜素树转换为累加树

最新推荐文章于 2024-07-25 19:34:38 发布

clementines_

最新推荐文章于 2024-07-25 19:34:38 发布

阅读量54

点赞数

文章标签： leetcode 算法数据结构 c++ Powered by 金山文档

本文链接：https://blog.csdn.net/qq_52097561/article/details/128897069

版权

leetcode 699.修建二叉搜索树

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

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

leetcode 699.修建二叉搜索树

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

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

同样利用二叉搜素树的性质解题：根节点的左子树小于根节点的值，右子树大于根节点的值。

递归三部曲：

确定递归函数的参数和返回值

这里递归函数可以有返回值，也可以没有。由于这个题涉及到新二叉树结构的构建，所以可以利用有返回值的递归函数完成新节点与其父节点的赋值操作。

返回值为二叉树节点的引用，参数为二叉树根节点、最小边界low以及最大边界high。

TreeNode* trimBST(TreeNode* root, int low, int high)

确定终止条件

碰到空节点返回空即可。

if(root == NULL) return NULL;

确定单层递归的逻辑

首先找到要修剪的节点并进行处理：

当前节点的值小于low，则找到其右子树，返回其右孩子。

当前节点的值大于high，则找到其左子树，返回其左孩子。

if(root->val < low){
    TreeNode* right = trimBST(root->right, low, high);
    return right;
}
if(root->val > high){
    TreeNode* left = trimBST(root->left, low, high);
    return left;
}

接下来要修改二叉树结构：

对于情况a，要将right节点赋到原root节点的位置，即赋给root的父节点的左孩子。

对于情况b，要将left节点赋到原root节点的位置，即赋给root的父节点的右孩子。

root->left = trimBST(root->left, low, high);    // root->left接入符合条件的左孩子
root->right = trimBST(root->right, low, high);    // root->right接入符合条件的右孩子
return root;

这里的逻辑是，假设根节点的左节点不符合要求，那么我们先执行root->left = trimBST(root->left, low, high); 使用root->left准备接住新的节点（即根节点的左节点的右孩子），然后以root->left作为新的当前节点再次进入递归，然后进入if(root->val < low)判断，返回right节点并将其赋给root->left

由此就完成了二叉树结构的重新构建。

整体代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root == NULL) return NULL;
        if(root->val > high){
            TreeNode* left = trimBST(root->left, low, high);
            return left;
        }
        if(root->val < low){
            TreeNode* right = trimBST(root->right, low, high);
            return right;
        }
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

迭代法

迭代法分为三步：

将root移动到[L, R] 范围内，注意是左闭右闭区间，先找到一个合适的根节点

剪枝左子树

剪枝右子树

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        if (!root) return nullptr;

        // 处理头结点，让root移动到[L, R] 范围内，注意是左闭右闭
        while (root != nullptr && (root->val < L || root->val > R)) {
            if (root->val < L) root = root->right; // 小于L往右走
            else root = root->left; // 大于R往左走
        }
        TreeNode *cur = root;
        // 此时root已经在[L, R] 范围内，处理左孩子元素小于L的情况
        while (cur != nullptr) {
            while (cur->left && cur->left->val < L) {
                cur->left = cur->left->right;
            }
            cur = cur->left;
        }
        cur = root;

        // 此时root已经在[L, R] 范围内，处理右孩子大于R的情况
        while (cur != nullptr) {
            while (cur->right && cur->right->val > R) {
                cur->right = cur->right->left;
            }
            cur = cur->right;
        }
        return root;
    }
};

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

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

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

因为要构造一棵平衡二叉树，本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间。构造平衡二叉树的分割点一定是数组中间位置节点。这里就会分为两种情况：如果有序数组长度为奇数，毫无疑问取中间的值作为根节点；如果有序数组长度为偶数，其实取中间位置的任一节点均可。

这里的递归思想在于不断分割：每一个小的有序数组继续分割。

递归三部曲：

确定递归函数的参数和返回值

删除二叉树节点，增加二叉树节点，都是用递归函数的返回值来完成，这样是比较方便的。同样本题要构造二叉树，依然用递归函数的返回值来构造中节点的左右孩子。递归函数返回节点的引用。

参数包括传入的有序数组，以及数组的左下标left和右下标right。我们在leetcode 654.最大二叉树中提过，在构造二叉树的时候尽量不要重新定义左右区间数组，而是用下标来操作原数组。这样在每层递归中就不需要定义新的vector了（既耗时又耗空间）。

// 左闭右闭区间[left, right]
TreeNode* traversal(vector<int>& nums, int left, int right)

这里定义的左闭右闭区间是代码中的循环不变量。

确定终止条件

// [ ]
if(left > right) return NULL;

确定单层递归的逻辑

首先取数组中间元素的位置，不难写出int mid = (left + right) / 2;，这么写其实有一个问题，就是数值越界，例如left和right都是最大int，这么操作就越界了，在二分法中尤其需要注意！

所以可以这么写：int mid = left + ((right - left) / 2);

接着划分区间，root的左孩子接住下一层左区间的构造节点，右孩子接住下一层右区间构造的节点。这也是返回值是TreeNode* 类型的好处

int mid = left + ((right - left) / 2);
TreeNode* root = new TreeNode(nums[mid]);
root->left = traversal(nums, left, mid - 1);
root->right = traversal(nums, mid + 1, right);
return root;

整体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left > right) return NULL;
        int mid = left + ((right - left) / 2);
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);    // ****
        return root;
    }
};

注意：在调用traversal的时候传入的left和right为什么是0和nums.size() - 1，因为定义的区间为左闭右闭。

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

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

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

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

本题依然需要一个pre指针记录当前遍历节点cur的前一个节点，这样才方便做累加。

递归三部曲：

确定递归函数的参数和返回值

本题不需要递归函数的返回值做什么操作了，要遍历整棵树。

同时需要定义一个全局变量pre，用来保存cur节点的前一个节点的数值，定义为int型。

代码如下：

int pre = 0; // 记录前一个节点的数值
void traversal(TreeNode* cur)

确定终止条件

if(cur == NULL) return;

确定单层递归的逻辑

注意要右中左来遍历二叉树，中节点的处理逻辑就是让cur的数值加上前一个节点的数值。

代码如下：

traversal(cur->right);  // 右
cur->val += pre;        // 中
pre = cur->val;
traversal(cur->left);   // 左

整体代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    int pre = 0;
    void traversal(TreeNode* cur){
        if(cur == NULL) return;
        traversal(cur->right);  // 右
        cur->val += pre;        // 中
        pre = cur->val;
        traversal(cur->left);   // 左   
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }
};