代码随想录算法训练营第十九天|LeetCode654 最大二叉树、617 合并二叉树、700 二叉搜索树中的搜索、98 验证二叉搜索树

654.最大二叉树

思路：递归终止条件，如果数组大小为1，返回对应值的结点。在数组中找到最大值，以及对应的索引，将最大值赋予根节点的值。然后将数组以最大值对应索引，分割成两个子数组，左边的数组用来根节点左边结点的递归，右边同理。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==1)
        {
            return new TreeNode(nums[0]);
        }
        int maxvalue=0;
        int index =0;
        for(int i =0;i<nums.size();i++)
        {
            if(nums[i]>maxvalue)
            {
                maxvalue = nums[i];
                index = i;
            }
        }
        TreeNode* node = new TreeNode(maxvalue);
        if(index>0)
        {
            vector<int> left_nums;
            for(int i =0;i<index;i++)
            {
                left_nums.push_back(nums[i]);
            } 
            node->left = constructMaximumBinaryTree(left_nums);
        }
        if(index<nums.size()-1)
        {
            vector<int> right_nums;
            for(int i=index+1;i<nums.size();i++)
            {
                right_nums.push_back(nums[i]);
            }
            node->right = constructMaximumBinaryTree(right_nums);
        }
        return node;
    }
};

617.合并二叉树

思路：将两颗二叉树合并成一颗，直接在树一上操作，把树二上的值加到树一上，终止条件为，如果树一处的结点为空，则返回树二的结点，如果树二的结点为空，则返回树一的结点。采用中左右的顺序。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==NULL) return root2;
        if(root2 ==NULL ) 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==NULL||root->val ==val) return root;
        TreeNode* result;
        if(val<root->val) result = searchBST(root->left,val);
        if(val>root->val) result = searchBST(root->right,val);
        return result; 

    }
};

递归法：中左右，判断值的大小，来移动root，如果没有搜索到，返回NULL。

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root!=NULL)
        {
            if(root->val>val)
            {
                 root = root->left;
            }
            else if (root->val<val)
            {
                 root = root->right;
            }
            else 
            {
                return root;
                }
        }
        return NULL;
    }
};

98.验证二叉搜索树

思路：判断左子树结点是否小于中间结点小于右子树结点。利用中序遍历，将二叉树中的元素排列到数组中，如果数组是单调递增的，则说明是二叉搜索树。

class Solution {
public:
vector<int> vec;
    void reserval(TreeNode* root)
    {
        if(root ==NULL)
        {
            return;
        }
        isValidBST(root->left);
        vec.push_back(root->val);
        isValidBST(root->right);
    }

    bool isValidBST(TreeNode* root) {
        //中序遍历
        if(root==NULL)
        {
            return true;
        }
        reserval(root);
        //判断数组是否有序
        for(int i =0;i<vec.size()-1;i++)
        {
            if(vec[i]>=vec[i+1])
            {
                return false;
            }
        }
        return true;
    }
};

利用递归法，双指针，终止条件为结点为空返回true，定义两个结点，一个是当前结点，另一个为前一个结点，如果前一个结点的值大于等于当前结点的值，就返回false。

class Solution {
public:
TreeNode*pre =NULL;
    bool isValidBST(TreeNode* root) {
        if(root==NULL) return true;
        bool left = isValidBST(root->left);
        if(pre!=NULL&&pre->val>=root->val)
        {
            return false;
        }
        pre=root;
        bool right = isValidBST(root->right);
        return left&&right;
    }
};