代码随想录算法训练营第十九天

代码随想录算法训练营第十九天

一、654.最大二叉树

​ 这题跟构造二叉树的题目一样，比较简单

class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int numsBegin, int numsEnd){
        if(numsBegin >= numsEnd)    return NULL;
        
        int maxIndex = numsBegin;
        for(int i = numsBegin + 1; i < numsEnd; i++){
            if(nums[i] > nums[maxIndex])    maxIndex = i;
        }

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

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

    }
};

二、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;
        if (root->val > val) return searchBST(root->left, val);
        if (root->val < val) return searchBST(root->right, val);
        return NULL;
    }
};

四、98.验证二叉搜索树

​ 这题有点陷入了陷阱：

1. ​ 不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。我们要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点。
2. 样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。此时可以初始化比较元素为longlong的最小值。

思路

​ 要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

​ 有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

中序遍历数组判断

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