修剪二叉搜索树 将有序数组转化为二叉搜索树 把二叉搜索树转换为累加树

1.给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x)
    {
        val=x;
        left=NULL;
        right=NULL;
    }
};
TreeNode* traversal(TreeNode* root,int low,int high)
{
    if(root==NULL)
    return NULL;
    if(root->val<low)
    {
        TreeNode* right=traversal(root->right,low,high);
        return right;
    }
    if(root->val>high)
    {
        TreeNode* left=traversal(root->left,low,high);
        return left;
    }
    root->left=traversal(root->left,low,high);
    root->right=traversal(root->right,low,high);
    return root;
}
void print(TreeNode* root)
{
    if(root==NULL)
    return ;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty())
    {
        int size=que.size();
        for(int i=0;i<size;i++)
        {
            TreeNode* node=que.front();
            que.pop();
            cout<<node->val<<" ";
            if(node->left)
            que.push(node->left);
            if(node->right)
            que.push(node->right);
        }
        cout<<endl;
    }    
}
int main()
{
    TreeNode* root=new TreeNode(7);
    root->left=new TreeNode(0);
    root->right=new TreeNode(9);
    root->left->right=new TreeNode(3);
    root->left->right->left=new TreeNode(2);
    print(root);
    cout<<endl;
    TreeNode* t=traversal(root,2,7);
    print(t); 
    return 0;
}

思路：这里我们要根据区间来移除二叉搜索树中不符合的元素，在结点不为空的情况下，如果其值小于区间左端值，这时应该继续向该结点的右子树进行遍历，因为它们可能大于区间左端值，如果其值大于区间右端值，这时应该继续向该结点的左子树进行遍历，因为它们可能小于区间右端值。

2.将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x)
    {
        val=x;
        left=NULL;
        right=NULL;
    }
};
TreeNode* traversal(vector<int>& num,int left,int right)
{
    if(left>right)
    return NULL;
    int mid=(left+right)/2;
    TreeNode* root=new TreeNode(num[mid]);
    root->left=traversal(num,left,mid-1);
    root->right=traversal(num,mid+1,right);
    return root;
}
void print(TreeNode* root)
{
    if(root==NULL)
    return ;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty())
    {
        int size=que.size();
        for(int i=0;i<size;i++)
        {
            TreeNode* node=que.front();
            que.pop();
            cout<<node->val<<" ";
            if(node->left)
            que.push(node->left);
            if(node->right)
            que.push(node->right);
        }
        cout<<endl;
    }
}
int main()
{
    vector<int> num={-10,-3,0,5,9};
    TreeNode* root=traversal(num,0,num.size()-1);
    print(root);
    return 0;
 } 

思路：对于这道题我们先根据已给数组来确定二叉树的根结点，为保证其符合平衡二叉树的特性，我们找数组中的中间位置来作为根结点，用mid来表示，之后为根结点寻找左右子树，那么此时mid的左侧区间就是根结点的左子树，右侧区间就是根结点的右子树。之后我们来递归左子树，确定参数，左区间left，右区间mid-1（默认区间左闭右闭），相应地递归右子树时参数左区间mid+1，右区间right。当然初始left为0，right为num.size（）-1。

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

#include <bits/stdc++.h>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x)
    {
        val=x;
        left=NULL;
        right=NULL;
    }
};
int pre=0;
void traversal(TreeNode* cur)
{
    if(cur==NULL)
    return ;
    traversal(cur->right);
    cur->val+=pre;
    pre=cur->val;
    traversal(cur->left);
}
void print(TreeNode* root)
{
    if(root==NULL)
    return ;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty())
    {
        int size=que.size();
        for(int i=0;i<size;i++)
        {
        TreeNode* node=que.front();
        que.pop();
        cout<<node->val<<" ";
        if(node->left)
        que.push(node->left);
        if(node->right)
        que.push(node->right);
        }
        cout<<endl;
    }
    
    
}
int main()
{
    TreeNode* root=new TreeNode(4);
    root->left=new TreeNode(1);
    root->right=new TreeNode(6);
    root->right->left=new TreeNode(5);
    root->right->right=new TreeNode(7);
    root->right->right->right=new TreeNode(8);
    print(root);
    traversal(root);
    cout<<endl;
    print(root);
}

思路：这道题就是将二叉搜索树中每个结点的值变为累加大于此结点的所有结点（包括累加本身），因此我们在开始时应该从该二叉树的最大值处进行累加，即右子树的最右侧结点，这里我们引入pre和cur指针，开始pre=0，cur指向最大值结点，然后递归遍历，顺序为右中左，每次遍历时我们进行cur->val+=pre,pre=cur->val操作，这样就实现了累加操作。