算法训练营Day20 第六章 二叉树 part6

第一题： 654.最大二叉树 

        这道题和前一天的最后一题比较类似，都是构造二叉树的题目。只要按照类似的方式进行递归就可以了，注意一下边界条件就ok。代码如下：

class Solution {
public:
    TreeNode* travesal(vector<int>& nums) {
        if(nums.size() == 0) return nullptr;
        int m_max = 0, index = 0;
        for(int i = 0; i < nums.size(); ++i) {
            if(nums[i] > m_max) {
                index = i;
                m_max = nums[i];
            }
        }
        TreeNode* root = new TreeNode(m_max);
        if(nums.size() == 1) return root;
        vector<int> leftTree(nums.begin(), nums.begin() + index);
        vector<int> rightTree(nums.begin() + index + 1, nums.end());
        root->left = travesal(leftTree);
        root->right = travesal(rightTree);
        return root;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return travesal(nums);
    }
};

 第二题： 617.合并二叉树

        这道题比较容易想到递归法，只要确定了递归终止条件，并且明确单层递归的逻辑，这道题就能够很好地解决啦！代码如下：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1 && !root2) return nullptr;
        if(root1 && !root2) return root1;
        if(!root1 && root2) return root2;
        TreeNode* root = new TreeNode(root1->val + root2->val);
        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);
        return root;
    }
};

第三题： 700.二叉搜索树中的搜索

         这道题可以利用二叉搜索树的特性，左子树中的元素都小于该节点的值，右子树中的元素都大于该元素的值，既可以使用递归法也可以使用迭代法，代码如下：

①递归法：

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

②迭代法：对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

例如要搜索元素为3的节点，我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。

class Solution {
public:
    TreeNode* 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.验证二叉搜索树 

        要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。注意：不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。

代码如下：

①递归法：

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

②迭代法：

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

        Day20打卡！！！