【代码随想录】算法训练营 第二十天 第六章 二叉树 Part 6

654. 最大二叉树

题目

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

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

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

其实就是根据数组来构建二叉树，选定其中最大的数作为根节点，数组中左边的放在左子树，右边的放在右子树，然后接下来就是递归做下去，直到完成二叉树的构建。

思路

和昨天的根据两个遍历序列构建二叉树的思想差不多，只不过这题更简单，我们只要三步走，首先是构建中间节点，这就需要找到值最大的节点。

代码

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        if (nums.size() == 1) {
            node->val = nums[0];
            return node;
        }
        int maxVal = 0;
        int index = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
                index = i;
            }
        }
        node->val = maxVal;
        if (index > 0) {
            vector<int> newVec(nums.begin(), nums.begin() + index);
            node->left = constructMaximumBinaryTree(newVec);
        }
        if (index < nums.size() - 1) {
            vector<int> newVec(nums.begin() + index + 1, nums.end());
            node->right = constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

617. 合并二叉树

题目

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

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

返回合并后的二叉树。

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

思路

对两个二叉树，合并相同位置的节点元素，这其实用前序遍历就可以完成，因为我们可以从上往下合并，从上往下的递归终止条件是其中一个遍历到空节点了，这时候就返回另一个二叉树此时遍历到的节点，因为两个二叉树的遍历是同步的；

接下来就是合并操作，这里我新定义了一个节点，然后将第一棵树的值传入，再加上第二棵树的值，最后就是继续合并子树了，递归调用函数本身即可。

代码

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);
        root->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 。

思路

二叉搜索树的一个节点如果有左孩子和右孩子的话，则节点值大于左孩子的值，小于右孩子的值。

要注意root为空时的特判。

代码

class Solution {
public:
    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);
    }
};

98. 验证二叉搜索树

题目

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

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

解法一：递归遍历，判断数组

这里涉及到一个知识点，中序遍历二叉搜索树，可以得到一个严格单调递增的序列，所以我们可以用递归法中序遍历输入的搜索树，得到一个数组，再判断这个数组是否为严格单调递增即可，注意这里是严格的，所以在数组中，后一个数一定比前一个数大。

class Solution {
private:
    vector<int> vec;
    void traverser(TreeNode* cur, vector<int> &vec) {
        if (cur == NULL) return;
        traverser(cur->left, vec);
        vec.push_back(cur->val);
        traverser(cur->right, vec);
    }
public:
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        vec.clear();
        traverser(root, vec);
        for (int i = 1; i < vec.size(); i++) {
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};

解法二：中序遍历，直接判断

这个方法是把答案函数直接递归，在这个过程中，边递归边判断，如果出现新遍历到的节点值小于等于上一个遍历到的节点值，就直接返回false。要注意，还是按照中序遍历。

class Solution {
public:
    long long maxVal = LONG_MIN; 
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);
        if (root->val > maxVal) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

在这个解法里，要先定义一个赋值为最小值的来作为存放最大值的变量，在这里我学到了整型最大值和最小值的表示方法：

整型最值	表示法
int 型最大值	INT_MAX
int 型最小值	INT_MIN
long long 型最大值	LONG_MAX
long long 型最小值	LONG_MIN