代码随想录训练营第二十天| ● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树-优快云博客

654.最大二叉树

题目链接/文章讲解：代码随想录

视频讲解：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size() == 0) return NULL;
        int maxIndex = 0;
        int max = 0;
        for (int i = 0; i < nums.size(); i++) {         //获取最大值索引
            if (max < nums[i]) {
                max = nums[i];
                maxIndex = i;
            }
        }
        TreeNode* root = new TreeNode(max);
        vector<int> left(nums.begin(), nums.begin()+maxIndex);
        vector<int> right(nums.begin()+maxIndex+1, nums.end());
        root->left = constructMaximumBinaryTree(left);
        root->right = constructMaximumBinaryTree(right);
        return root;
    }

这道题还可以，和上次构建二叉树思想差不多，我的思路是先找到最大值和最大值的索引，然后创建最大值的节点当做根节点，再递归的创建根节点的左右子节点。

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

也可以利用数组的下标来进行遍历，能节省创建新数组的空间，代码如下：

class Solution {
private:
    // 在左闭右开区间[left, right)，构造二叉树
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right) return nullptr;

        // 分割点下标：maxValueIndex
        int maxValueIndex = left;
        for (int i = left + 1; i < right; ++i) {
            if (nums[i] > nums[maxValueIndex]) maxValueIndex = i;
        }

        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        // 左闭右开：[left, maxValueIndex)
        root->left = traversal(nums, left, maxValueIndex);

        // 左闭右开：[maxValueIndex + 1, right)
        root->right = traversal(nums, maxValueIndex + 1, right);

        return root;
    }
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

617.合并二叉树

题目链接/文章讲解：代码随想录

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL) return root2; // 如果t1为空，合并之后就应该是t2
        if (root2 == NULL) return root1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        root1->val += root2->val;                             // 中
        root1->left = mergeTrees(root1->left, root2->left);      // 左
        root1->right = mergeTrees(root1->right, root2->right);   // 右
        return root1;
    }

使用递归的方法可完成，实际上是两个数的同时递归，如果遇到了空节点，就返回另一个节点；如果不是空节点，则返回两节点之和。

不修改root1的结构也可以，创建新的节点即可：

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        // 重新定义新的节点，不修改原有两个树的结构
        TreeNode* root = new TreeNode(0);
        root->val = t1->val + t2->val;
        root->left = mergeTrees(t1->left, t2->left);
        root->right = mergeTrees(t1->right, t2->right);
        return root;
    }

700.二叉搜索树中的搜索

题目链接/文章讲解: 代码随想录

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

TreeNode* searchBST(TreeNode* root, int val) {
        if (root == NULL) return NULL;
        if (root->val == val) return root;
        else if(root->val < val) return searchBST(root->right, val);
        else return searchBST(root->left, val);
    }

很简单，类似二分法思路。

使用迭代法也能很简单地解决，因为是搜索二叉树不需要回溯：

reeNode* 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.验证二叉搜索树

题目链接/文章讲解：代码随想录

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

bool isValidBST(TreeNode* root) {
        if (!root->right && !root->left) return true;

        if (root->left && root->left->val < root->val)
            return isValidBST(root->left);
        else return false;
        if (root->right && root->right->val > root->val)
            return isValidBST(root->right);
        else return false;
    }

这是一开始的思路，单纯比较了父节点和左右子节点，这样是不对的，因为二叉搜索树指的是左子树的所有子节点的元素都小于父节点，右子树都大于！

首先可以简单的采取中序遍历将节点树转换为数组，判断是否为递增数组即可：

class Solution {
private:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if (root == NULL) return;
        traversal(root->left);
        vec.push_back(root->val); // 将二叉搜索树转换为有序数组
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
        traversal(root);
        for (int i = 1; i < vec.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};

如果不采用数组的话，也可以使用递归方法，但需要创建一个最小值来判断元素大小：

class Solution {
public:
    long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;

        bool left = isValidBST(root->left);
        // 中序遍历，验证遍历的元素是不是从小到大
        if (maxVal < root->val) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);

        return left && right;
    }
};

直接采用中序遍历，首先会在左子树中更新最大值，若比中间节点大则返回false；之后继续在右子树中遍历。如果到了叶子结点仍没问题，则说明二叉搜索树正确。其中maxVal实际上是要在遍历每个节点时更新的，也就是在遍历到每个节点时都要比它们的值小。

最重要的思想就是：搜索二叉树——>中序遍历！！