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

1. 题目：

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

• 二叉树的根是数组中的最大元素。
• 左子树是通过数组中最大值左边部分构造出的最大二叉树。
• 右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

class Solution {

public:

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {

        TreeNode* node = new TreeNode(0);

        if (nums.size() == 1) {

            node->val = nums[0];

            return node;

        }

        // 找到数组中最大的值和对应的下标

        int maxValue = 0;

        int maxValueIndex = 0;

        for (int i = 0; i < nums.size(); i++) {

            if (nums[i] > maxValue) {

                maxValue = nums[i];

                maxValueIndex = i;

            }

        }

        node->val = maxValue;

        // 最大值所在的下标左区间 构造左子树

        if (maxValueIndex > 0) {

            vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);

            node->left = constructMaximumBinaryTree(newVec);

        }

        // 最大值所在的下标右区间 构造右子树

        if (maxValueIndex < (nums.size() - 1)) {

            vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());

            node->right = constructMaximumBinaryTree(newVec);

        }

        return node;

    }

};

2. 题目：

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

class Solution {

public:

    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

        if (t1 == NULL) return t2;

        if (t2 == NULL) return t1;

        queue<TreeNode*> que;

        que.push(t1);

        que.push(t2);

        while(!que.empty()) {

            TreeNode* node1 = que.front(); que.pop();

            TreeNode* node2 = que.front(); que.pop();

            // 此时两个节点一定不为空，val相加

            node1->val += node2->val;

            // 如果两棵树左节点都不为空，加入队列

            if (node1->left != NULL && node2->left != NULL) {

                que.push(node1->left);

                que.push(node2->left);

            }

            // 如果两棵树右节点都不为空，加入队列

            if (node1->right != NULL && node2->right != NULL) {

                que.push(node1->right);

                que.push(node2->right);

            }

            // 当t1的左节点 为空 t2左节点不为空，就赋值过去

            if (node1->left == NULL && node2->left != NULL) {

                node1->left = node2->left;

            }

            // 当t1的右节点 为空 t2右节点不为空，就赋值过去

            if (node1->right == NULL && node2->right != NULL) {

                node1->right = node2->right;

            }

        }

        return t1;

    }

};

3. 题目：

给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

## 递归法思考返回条件，先以根节点考虑：（1）是否为空（root == NULL），判断递归返回条件；（2）不为空看看左右子树（root -> next）；（3）不为空看看其值或者左右子树的值。

## 递归单层逻辑，以根节点和叶子结点考虑：（1）左右指针（root -> left）或（root -> right）一般都是! left 或者 ！right（2）根val值（root->val）

## 递归法

class Solution {

public:

    TreeNode* searchBST(TreeNode* root, int val) {

        if (root == NULL || root->val == val) return root;

        // 临时值记得申请保存

        TreeNode* result = NULL;

        if (root->val > val) result = searchBST(root->left, val);

        if (root->val < val) result = searchBST(root->right, val);

        return result;

    }

};

## 遍历法

class solution{

public:

        TreeNode* binarySearch(TreeNode* root, int val){

                if(root == NULL || root -> val == val) return root;

                TreeNode* temp = new TreeNode(0);

                while(! root){

                        if (root -> val > val) root = root -> left; 

                        else if (root -> val < val) root = root -> right;

                        else return root; // 相等情况下

                }

                return NULL;

        }

};

4. 题目：

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

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

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

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;

    }

};