代码随想录训练营day 17 | Leetcode

Leetcode 654 最大二叉树

题述：给定一个不含重复项的数组，构建最大二叉树。

首先找到数组的最大值，作为根节点，然后以此划分左右区间分别为左右子树。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        if(nums.size() == 1){
            node -> val = nums[0];
            return node;
        }
        int maxValue = -1;
        int maxValueIndex = 0;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > maxValue) {
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        node -> val = maxValue;
        //left左闭有开
        if(maxValueIndex > 0)
        {vector<int> leftVec(nums.begin(), nums.begin() + maxValueIndex);
        node -> left = constructMaximumBinaryTree(leftVec);}
        //right
        if(maxValueIndex < nums.size() - 1)
        {vector<int> rightVec(nums.begin() + maxValueIndex + 1, nums.end());
        node -> right = constructMaximumBinaryTree(rightVec);
}
        return node;
    }
};

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

Leetcode 700 二叉搜索树中的搜索

二叉搜索树的左子树<根节点<右子树。

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

Leetcode 98 验证二叉搜索树

二叉搜索树的中序遍历是一个升序数组。

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

    bool isValidBST(TreeNode* root) {
        vector<int> vec;
        midTravesal(root, vec);
        if(vec.size() == 0 || vec.size() == 1) {return true;}
        for(int i = 1; i < vec.size(); i++){
            if(vec[i] <= vec[i - 1]) {return false;}
        }
        return true;
    }
};