二叉搜索树

1038. 从二叉搜索树到更大和树

给出二叉 搜索 树的根节点，该二叉树的节点值各不相同，修改二叉树，使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

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

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

思路：逆中序遍历，一个全局变量的累加，也就是右子树的累加的最少，根结点次之，左子树最多，因为比他大的最多，所以放在后面访问他

class Solution {
public:
    int sum=0;
    TreeNode* bstToGst(TreeNode* root) {
        if(root!=NULL){
            bstToGst(root->right);
            root->val+=sum;
            sum = root->val;
            bstToGst(root->left);
        }
        return root;
    }
    
};

1382. 将二叉搜索树变平衡

给你一棵二叉搜索树，请你返回一棵 平衡后 的二叉搜索树，新生成的树应该与原来的树有着相同的节点值。

如果一棵二叉搜索树中，每个节点的两棵子树高度差不超过 1 ，我们就称这棵二叉搜索树是 平衡的 。

如果有多种构造方法，请你返回任意一种。

思路：就是先通过先序遍历得到有序的数组，然后根据的类似二分，进行重新创建一个平衡二叉树

class Solution {
public:
    vector<int>ordernumber;
    void gengerate(TreeNode *root){
        if(root!=NULL){
            gengerate(root->left);
            ordernumber.push_back(root->val);
            gengerate(root->right);
        }
    }
    TreeNode *creat(int l,int r){
        int m = (l+r)>>1;
        TreeNode *root = new TreeNode(ordernumber[m]);
        if(l<=m-1){
            root->left = creat(l,m-1);
        }
        if(r>=m+1){
            root->right = creat(m+1,r);
        }
        return root;
    }
    TreeNode* balanceBST(TreeNode* root) {
        gengerate(root);
        TreeNode *r = creat(0,ordernumber.size()-1);
        return r;
    }
};

1373. 二叉搜索子树的最大键值和

给你一棵以 root 为根的 二叉树 ，请你返回 任意 二叉搜索子树的最大键值和。

二叉搜索树的定义如下：

任意节点的左子树中的键值都 小于 此节点的键值。
任意节点的右子树中的键值都 大于 此节点的键值。
任意节点的左子树和右子树都是二叉搜索树。

 

思路：递归判断当前节点的树是不是二叉搜索树：

（1）左右子树是不是都是二叉搜索树

（2）当前节点的值是不是大于左子树的最大值

（3）当前节点的值是不是小于其右子树的的最小值

所以可以返回一个数组，里面存放着[是不是二叉搜索树，当前树的最小值，最大值，当前树的最大和]

这里面有个全局变量maxsum代表始终表示当前某个最大的和，局部变量表示当前节点的的树的和，因为是当前值和左子树和右子树的和，所以只是个临时变量

class Solution {
public:
    int maxsum = 0;
    int p=100000;
    int Max = 50000;
    int Min = -50000;
    //vecot[bool,min,max,sum]
    vector<int>maxTree(TreeNode *root){
        if(root==NULL)return {true,Max,Min,0};
        vector<int>l;
        vector<int>r;
        int sum = 0;
        int curmin = 0;
        int curmax = 0;
        l = maxTree(root->left);
        r = maxTree(root->right);
        if(!l[0]||!r[0]||root->val<=l[2]||root->val>=r[1]){
            return {false,l[1],r[2],0};
        }
        else{
            sum=root->val+l[3]+r[3];
            curmin = root->left ? l[1]:root->val;
            curmax = root->right ? r[2]:root->val;
            maxsum = max(sum,maxsum);
            return {true,curmin,curmax,sum};
            
        }
    }
    int maxSumBST(TreeNode* root) {
        maxTree(root);
        return maxsum;
    }
};

 

 

总结：从这个三个二叉搜索树的题目来看，搜索树大都会使用递归，应该树大都递归，只要找准的先后顺序，并且一般会设置一个全局变量，表示要求的值