654.最大二叉树

题目链接 文章讲解 视频讲解

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return inorderTraversal(nums, 0, nums.size() - 1);
    }
    TreeNode* inorderTraversal(vector<int>& nums, int begin, int end) {
        if(begin > end) return nullptr;
        // 查找最大值，构造根节点
        int maxValueIndex = findMax(nums, begin, end);
        TreeNode * root = new TreeNode(nums[maxValueIndex]);
        // 先序遍历最区间构造左子树
        root->left = inorderTraversal(nums, begin, maxValueIndex - 1);
        // 先序遍历有区间构造右子树
        root->right = inorderTraversal(nums, maxValueIndex + 1, end);
        return root;
    }
    // 查找最大值
    int findMax(vector<int>& nums, int left, int right) {
        int idx = left;
        while(left <= right) {
            if(nums[idx] < nums[left]) idx = left;
            ++left;
        }
        return idx;
    }
};

617.合并二叉树

题目链接 文章讲解 视频讲解

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == nullptr) return root2; // 如root1为nullptr，则合并之后时root2，如果root2也为nullptr那么合并之后为nullptr
        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 nullptr;
        TreeNode* ans = nullptr;
        if(root->val == val) ans = root;
        if(root->val > val) ans = searchBST(root->left, val);
        if(root->val < val) ans = searchBST(root->right, val);
        return ans;
    }
};

98.验证二叉搜索树

题目链接 文章讲解 视频讲解

方法一

中序遍历二叉搜索树，如果生成的数组有序则二叉树为二叉搜索树

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        vector<int> ans;
        preorderTraversal(root, ans);
        // 判断数组是否有序
        for(int i = 0; i < ans.size() - 1; ++i) {
            if(ans[i] >= ans[i+1]) return false;
        }
        return true;
    }
    // 中序遍历二叉搜索树，构造有序数组；
    void preorderTraversal(TreeNode* root, vector<int>& ans) {
        if(root == nullptr) return;
        preorderTraversal(root->left, ans);
        ans.push_back(root->val);
        preorderTraversal(root->right, ans);
    }
};

方法二

不构造数组，而使用一个maxValue来记录当前值的前一个值

class Solution {
private:
    long long maxValue = LONG_MIN;
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;
        // 先序遍历左子树
        bool left = isValidBST(root->left);
        // 如果当前值比前一个值小则retun false;
        if(root->val > maxValue) {
            maxValue = root->val;
        } else {
            return false;
        }
        // 先序遍历右子树
        bool right = isValidBST(root->right);
        return left && right;
    }
};