代码随想录day20｜最大二叉树、合并二叉树、二叉搜索树中的搜索、验证二叉搜索树

最大二叉树

 当我们需要构造一个二叉树的时候，我们应该选用前序遍历的方法，我们先得到根节点，然后再遍历左右节点。这道题给出了nums.size()>=1，逐个遍历，nums.size肯定是在逐渐变小，只要等于1的时候就说明到了叶子节点，就可以中止遍历了。我们首先需要找到一个数组中的最大的节点，然后在其左边递归，然后在其右边递归。接下来给出的代码是存在冗余的，原因是因为我们每次递归都需要定义新的数组。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        //确定中止条件
        if(nums.size() == 1) 
        {
            return (new TreeNode(nums[0]));
        }

        //单层递归逻辑
        //中
        int maxValue = 0;//数组中的最大值
        int maxValueIndex = 0;//最大值的下标
        for(int i = 0;i < nums.size();i++)
        {
            if(nums[i] > maxValue)
            {
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        TreeNode* node = new TreeNode(0);
        node->val = maxValue;

        //左
        if(maxValueIndex > 0)//首先需要判断左区间不为空，至少要有点一个节点
        {
            vector<int> leftNums(nums.begin(),nums.begin() + maxValueIndex);
            node->left = constructMaximumBinaryTree(leftNums);
        }

        //右
        if(maxValueIndex < (nums.size() - 1))//右区间不能为空,至少要有一个节点
        {
            vector<int> rightNums(nums.begin() + maxValueIndex + 1,nums.end());
            node->right = constructMaximumBinaryTree(rightNums);
        }

        return node;
    }
};

 通过索引优化代码，可以使得我们的代码不再那么冗余。

class Solution {
private:
    TreeNode* traversal(vector<int>& nums,int left,int right)
    {
        if(left >= right) return NULL;
        //中
        int maxValueIndex = left;
        for(int i = left + 1;i < right;i++)
        {
            if(nums[i] > nums[maxValueIndex]) maxValueIndex = i;
        }
        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        //左
        root->left = traversal(nums,left,maxValueIndex);
        //右
        root->right = traversal(nums,maxValueIndex + 1,right);
        return root;
    }
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums,0,nums.size());
    }
};

合并二叉树

 

 这道题是同时操纵两个二叉树，我们采用前序遍历的方法，直接在第一个二叉树上进行修改，第一棵二叉树的节点加上第二棵二叉树的节点，然后分别左右递归遍历。

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;
    }
};

二叉搜索树中的搜索

由于二叉搜索树是有序的，因此我们只要判断我们要所要的那个数是不是大于节点还是小于节点， 如果小于节点，直接往左搜索；如果大于节点，直接往右搜索。

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

 验证二叉搜索树

我们设置一个节点pre，我们每次遍历的时候root都与这个节点进行比较，只有root->val > pre->val的时候才能通过，如果不满足这个条件就return fasle，这个pre是root的前一个节点，我们这次将pre更新为root后，下次再次比较的就是下次的root和这次的root。并且在if语句中需要加入pre!=NULL，这是因为一开始pre是NULL，我们遍历最小的节点的时候无法比较，因此要设置一个条件。

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;
    }
};