算法学习打卡day19｜654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

654.最大二叉树

力扣题目链接
题目描述：
给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

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

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：

• [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
  • [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
    • 空数组，无子节点。
    • [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
      • 空数组，无子节点。
      • 只有一个元素，所以子节点是一个值为 1 的节点。
  • [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
    • 只有一个元素，所以子节点是一个值为 0 的节点。
    • 空数组，无子节点。

思路：

• 和前中后序遍历构造二叉树类似，这个还比那个简单点，依然是先构造根节点，然后再构造左右子树，这道题是先求数组的最大值，然后将最大值作为根节点，最大值左侧的元素为左子树，右侧元素为右子树。
• 按三步来做：
  • 第一步：节点为空，直接返回nullptr
  • 第二步：求得最大值，以及下标max_index，并用最大值当作根节点，如果数组大小为1，此时就直接可以返回root啦
  • 第三步：根据max_index切分左右子树区间，依然是左闭右开的原则，递归左右子树，接到root上，最后返回root即可

代码实现：

TreeNode* traversal(vector<int>& nums, int begin, int end) {
        if (begin == end)   return nullptr;

        //找最大值
        int max = nums[begin], max_index = begin;
        for (int i = begin; i < end; i++) {
            if (max < nums[i]) {
                max_index = i;
                max = nums[i];
            }
        }
        TreeNode* root = new TreeNode(max);
        if (begin - end == 1)   return root;

        // 递归
        root->left = traversal(nums, begin, max_index);
        root->right = traversal(nums, max_index + 1, end);
        return root;

    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }

• 思考总结：
  • 注意类似用数组构造二叉树的题目，每次分隔尽量不要定义新的数组，而是通过下标索引直接在原数组上操作，这样可以节约时间和空间上的开销。
  • 什么时候递归函数前面加if，什么时候不加if
    • 其实就是不同代码风格的实现，一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。

617.合并二叉树

力扣题目链接
题目描述：
给你两棵二叉树： root1 和 root2 。

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

示例 1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

思路：

• 递归法：这个题同时遍历两颗树，采用前序遍历，如果左子树为空就返回右子树，右子树为空就返回左子树，如果左右子树都不为空，把这两个节点值加起来，新构造一个节点，当然用以前的也行。
  代码实现

TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == nullptr)   return root2;
        if (root2 == nullptr)   return root1;
        root1->val += root2->val;
        root1->left = mergeTrees(root1->left, root2->left);
        root1->right = mergeTrees(root1->right, root2->right);
        return root1;
    }

• 迭代法

700.二叉搜索树中的搜索

力扣题目链接
题目描述：
给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

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

思路：

• 递归法：二叉搜索树的遍历和普通二叉树遍历有些不同，下面是三部曲：
  • 函数参数是根节点和目标值，返回值为所求的目标节点（目标子树）
  • 退出条件为：if (root == nullptr || root->val == val) return root;
  • 单步处理逻辑：如果val比root->val值大，就遍历右子树，否则就遍历左子树。
• 迭代法：和递归法类似，如果val比root->val值大，就往右找，否则就往左找。

代码实现：

• 递归法：

TreeNode* searchBST(TreeNode* root, int val) {
        if (root == nullptr || root->val == val) return root;
        if (root->val > val) {
            return searchBST(root->left, val);
        } else {
            return searchBST(root->right, val);
        }
        return nullptr;
    }

• 迭代法：

TreeNode* searchBST(TreeNode* root, int val) {
        if (root == nullptr) return nullptr;
        TreeNode* cur = root;
        while (cur) {
            if (cur->val == val) {
                return cur;
            } else if (cur->val > val) {
                cur = cur->left;
            } else {
                cur = cur->right;
            }
        }
        return nullptr;
    }

98.验证二叉搜索树

力扣题目链接
题目描述：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

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

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

容易陷入的误区：

• 不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了，只比较了每个节点是否符合条件，但其实跟节点要比所有左子树的节点都要大，比右子树所有节点都要小。
  

然后写出了类似这样的代码：

if (root->val > root->left->val && root->val < root->right->val) {
    return true;
} else {
    return false;
}

解题思路：

• 这道题要用到二叉搜索树的一个性质：二叉搜索树的中序遍历结果是整体有序的，所以我们可以中序遍历把结果存到一个vector里，然后判断数组是否又序即可。
• 优化： 其实不需要存到数组中，在中序遍历的时候就可以直接判断了，我们每遍历一个元素都和前一个元素做比较，比前一个元素小或者等于（二叉搜索树没有相同元素），直接 return false。
• 递归三部曲：
  • 确定参数和返回值：参数就是根节点，返回值为bool类型，判断是否为搜索树嘛
  • 退出条件：判断节点是否为空，为空就返回true，否则为false
  • 单步处理逻辑：采用中序遍历，那么先判断左子树，然后处理当前节点和上一个节点比较，if (pre && pre->val >= root->val) return false;，比较完后将当前节点赋值给pre，以被下一个节点使用。

代码实现

TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if (root == nullptr)    return true;
        bool left = isValidBST(root->left);
        if (pre && pre->val >= root->val)   return false;
        pre = root;//记录前一个节点
        return left && isValidBST(root->right);
    }

• 迭代法：同样采用中序遍历解题，在中序遍历的代码上增加和上一个节点的比较即可

bool isValidBST(TreeNode* root) {
        if (root == nullptr)    return true;
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        TreeNode* pre = nullptr;
        while (cur || !stk.empty()) {
            if (cur) {
                stk.push(cur);
                cur = cur->left;
            } else {
                cur = stk.top();
                stk.pop();
                if (pre && pre->val >= cur->val)    return false;
                pre = cur; //记录前一个节点的值
                cur = cur->right;
            }
        }
        return true;
    }