代码随想录算法训练营第二十天 |力扣654 最大二叉树 力扣 617.合并二叉树 力扣700 二叉搜索树中的搜索 力扣98 验证二叉搜索树

day20 记录代码随想录

第一题 力扣654 最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

题目链接：力扣题目地址

跟昨天的中后序遍历构建二叉树的思想是一样的，代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findMaxIndex(vector<int>& nums) {
        int m = - 1;
        int Maxindex = - 1;
        for(int i = 0; i < nums.size(); i++) {
            if(nums[i] > m) {
                m = nums[i];
                Maxindex = i;
            }
        }
        return Maxindex;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if (nums.size() == 0)   return NULL;
        int index = findMaxIndex(nums);
        TreeNode* root = new TreeNode(nums[index]);
        if (nums.size() == 1)   return root;
        vector<int> leftnums(nums.begin(), nums.begin() + index);
        vector<int> rightnums(nums.begin() + index + 1, nums.end());
        root->left = constructMaximumBinaryTree(leftnums);
        root->right = constructMaximumBinaryTree(rightnums);
        return root;
    }
};

第二题 力扣 617.合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

题目链接：力扣题目链接

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == NULL)   return root2;
        if(root2 == NULL)   return root1;
        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 二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

题目链接：力扣题目地址

二叉搜索树：对于所有节点，都有：左子树上所有值都小于节点值，右子树上所有值都大于节点值。

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(val == root->val) return root;
        if(!root->left && !root->right) return NULL;
        if(val > root->val) {
            if(root->right) return searchBST(root->right,val);
            else return NULL;
        }

        if(val < root->val) {
            if(root->left) return searchBST(root->left,val);
            else return NULL;
        }
        return NULL;
    }
};

第四题 力扣98 验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

题目链接：力扣题目链接

迭代法：中序遍历的有序性，将遍历点存入数组中，判断数组是否有序。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> arr;
    void traversal(TreeNode* node) {
        if (node == NULL)   return;
        traversal(node->left);
        arr.push_back(node->val);
        traversal(node->right);
    }

    bool isValidBST(TreeNode* root) {
        arr.clear();
        traversal(root);
        for(int i = 1; i < arr.size(); i++ ) {
            if (arr[i] <= arr[i-1]) return 0;
        }
        return 1;
    }
};