day-20 代码随想录算法训练营（19）二叉树part06

654.最大二叉树

思路一：切割数组，生成新的左右数组

思路二：使用指针直接操作

class Solution {
public:
    TreeNode*judge(vector&nums,int left,int right){
        if(left>=right) return nullptr;
        //分割点下标
        int maxNum=nums[left],index=left;//maxNum初始值为区间最左边的数
        for(int i=left+1;imaxNum){
                maxNum=nums[i];
                index=i;
            }
               
        }
        //cout< leftNums(nums.begin(),nums.begin()+index);
        // vector rightNums(nums.begin()+index+1,nums.end());
        root->left=judge(nums,left,index);
        root->right=judge(nums,index+1,right);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector& nums) {
        //思路二：不进行切割，直接在原数组上进行操作
        return judge(nums,0,nums.size());
    }
};

617.合并二叉树

思路一：创建新的二叉树

思路二：直接在二叉树上操作

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        //思路：直接同时遍历两个二叉树，子节点不存在传入下一个为空指针
        if(root1==nullptr) return root2;
        if(root2==nullptr) return root1;
        root1->val+=root2->val;
        root1->left=mergeTrees(root1->left,root2->left);
        root1->right=mergeTrees(root1->right,root2->right);
        return root1;

    }
};

700.二叉树中的搜索

思路：利用二叉搜索树的特性

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        //思路：找到节点，然后返回
        //分析：左子节点比父节点小，右子节点比父节点大
        if(root==nullptr)
            return root;
        TreeNode*newNode=root;;
        if(newNode->val>val)
            newNode=searchBST(newNode->left,val);
        else if(newNode->valright,val);
        return newNode;
    }
};

98.验证二叉搜索树

思路一：利用二叉搜索树的特性，中序遍历的数组必为升序

class Solution {
public:
    vectorans;
    void judge(TreeNode*root){
        if(root==nullptr) return;
        judge(root->left);
        ans.push_back(root->val);
        judge(root->right);
    }
    bool isValidBST(TreeNode* root) {
        //思路：直接分析
        //思路二：中序遍历的数组一定递增
        judge(root);
        if(ans.size()==1) return true;
        int pre=ans[0];
        for(int i=1;i

思路二：在递归的过程中直接判断，采用中序遍历，每次都记录上一个节点，然后判断当前节点是否大于上一个节点

class Solution {
public:
    TreeNode*pre=nullptr;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;//空树也是二叉搜索树
        bool left=isValidBST(root->left);

        if(pre!=nullptr && pre->val>=root->val) return false;//判断上一个节点是否小于当前节点
        pre=root;

        bool right=isValidBST(root->right);
        return left && right; 
        
    }
};

669.修剪二叉搜索树

分析：分情况讨论，伪代码实现成代码，嗖嗖的

思路一：分析三种情况

           1.当前节点值在中间区间上（此时递归分析左右子节点）

           2.当前节点值在区间左边（此时当前节点不作为结果值，但右子节点中可能存在结果值，故返回分析右子节点）

           3.当前节点值在区间右边（同理，当前节点不作为结果值，但左子节点可能存在结果值，故返回分析左子节点）

注意：判断当前节点为空时返回nullptr，可以解决叶子节点问题，也可以解决当前节点等于row或者等于high的问题。

class Solution {
public:
    TreeNode*judgeNode(TreeNode*root,int low,int high){
        if(root==nullptr) return root;
        //分五种情况
        TreeNode*left,*right;
        if(root->valright,low,high);
        else if(root->val>=low && root->val<=high){//左右两边都有可能在区间内
            left=judgeNode(root->left,low,high);
            right=judgeNode(root->right,low,high);
        }
        else if(root->val>high){
            return judgeNode(root->left,low,high);
        }
        root->left=left;
        root->right=right;
        return root;
        
    }
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        //思路：首先考虑当前中间节点有三种情况，在low左边，在high右边
        return judgeNode(root,low,high);
    }
};

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

思路一：使用两个指针分割区间，每次都选择中间的值作为根节点，然后向两边切割

class Solution {
public:
    TreeNode*judge(vector&nums,int left,int right){
       if(left>right) return nullptr;
       //每次都选择区间中间的数作为根节点
       int mid=(left+right)/2;
       TreeNode*root=new TreeNode(nums[mid]);
       root->left=judge(nums,left,mid-1);
       root->right=judge(nums,mid+1,right);
       return root;
    }
    TreeNode* sortedArrayToBST(vector& nums) {
        //思路一：高度平衡，递归切割
        //后序遍历
        return judge(nums,0,nums.size()-1);
    }
};

分析：思路是这样，但是想复杂了，直接搞得分割区间，导致越来越乱

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

思路：遍历顺序为右中左，然后累加赋值

class Solution {
public:
    int sum=0;
    TreeNode* convertBST(TreeNode* root) {
        //思路：遍历顺序为右中左，然后累加赋值
        if(root!=nullptr){
            convertBST(root->right);
            sum+=root->val;
            root->val=sum;
            convertBST(root->left);
        }
        return root;
    }
};