代码随想录算法训练营第十九天|Leetcode654 最大二叉树、Leetcode617 合并二叉树、Leetcode700 二叉搜索树中的搜索、Leetcode98 验证二叉搜索树

● Leetcode654 最大二叉树

题目链接：Leetcode654 最大二叉树
视频讲解：代码随想录|最大二叉树
题目描述：给定一个不重复的整数数组 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 的节点。
-空数组，无子节点。

示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：
1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

● 解题思路

根据示例一中构建最大二叉树的解释：

解释：递归调用如下所示：
-[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 的节点。
-空数组，无子节点。

我们在遍历之前仍然需要判断其遍历方式：
在构建最大二叉树时，总是先构建中结点，然后再构建其左右结点，所以其遍历方式为前序遍历。

需要在传入数组中寻找到最大的值maxValue，令其下标为maxIndex，我们对数组进行分割得到[0, maxIndex)和[maxIndex + 1, size)左右两个数组，然后向下递归将左数组元素构建为左子树，右数组元素构建为右子树（构建过程中严格遵照子数组最大值左边元素为左子树，右边元素为右子树）；

同时需要注意的是，当我们的终止条件为遍历到叶子结点时，也就是当数组元素剩余一个，将其返回时，需要在递归前对数组元素大小进行判断，使得必须有一个元素。

● 代码实现

/**
 * 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* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        //终止条件
        if(nums.size() == 1)
        {
            node->val = nums[0];
            return node;
        }

        //寻找数组中最大值及下标
        int maxValue = 0, maxIndex = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] > maxValue)
            {
                maxValue = nums[i];
                maxIndex = i; 
            }
        }

        node->val = maxValue;
        //构建左右子树
        if(maxIndex > 0)
        {
            //分割左数组：[0, maxIndex)
            vector<int> newnums(nums.begin(), nums.begin() + maxIndex);
            node->left = constructMaximumBinaryTree(newnums);
        }
        if(maxIndex < (nums.size() - 1))
        {
            //分割右数组：[maxIndex + 1, nums.size())
            vector<int> newnums(nums.begin() + maxIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(newnums);
        }

        return node;
    }
};

通过对以上代码分析，每次递归调用栈帧构建左右子树时，都会额外地创建数组空间，使得代码效率并非最高，因此可以对其进行优化，可以使用下标对最大二叉树进行构建,数组依然遵循左闭右开的循环不变量，但终止条件会改变为遇到空结点返回：

/**
 * 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* traversal(vector<int>& nums, int left, int right)
    {
        //终止条件：数组为空
        if(left == right) return nullptr;

        //寻找最大值
        int maxIndex = left;
        for(int i = left + 1; i < right; i++)
        {
            if(nums[i] > nums[maxIndex])
            {
                maxIndex = i;
            }
        }
        TreeNode* node = new TreeNode(nums[maxIndex]);

        //左数组：[left, maxIndex)
        node->left = traversal(nums, left, maxIndex);
        //右数组：[maxIndex + 1, right)
        node->right = traversal(nums, maxIndex + 1, right);

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

在寻找最大值时要注意，我们传入了数组的开始下标和终止下标，就需要对i的限定进行修改，不能是数组size，不然会越界。

● Leetcode617 合并二叉树

题目链接：Leetcode617 合并二叉树
视频讲解：代码随想录|合并二叉树
题目描述：给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。

示例 1：

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

提示：
两棵树中的节点数目在范围 [0, 2000] 内
-104 <= Node.val <= 104

● 解题思路

方法一：递归
确定二叉树遍历方式：
对于合并二叉树，我们需要知道两棵树是同步遍历，而非异步遍历，因此在遍历过程中不需要担心遍历第一棵树时，第二棵树遍历到哪。对于遍历方式，使用哪种遍历方式都可以，但按照常规思维进行二叉树合并，习惯于从上到下进行合并，因此使用前序遍历更符合习惯；
同时我们可以在任意一颗树的原值上进行改变，也可以新创建一棵树进行合并。

（1）确定递归函数参数和返回值：
我们需要返回最后合并二叉树的根结点，返回值为Treenode*，传入参数为两棵树的根结点；
（2）确定递归终止条件：
当遍历左子树结点为空时，返回右子树结点；相反遍历右子树结点为空，返回左子树结点。

不需要对两棵树都为空进行判断，因为两棵树都为空返回nullptr正好包括在了以上两种情况。

（3）确定单层遍历逻辑：
当我们选择在root1或root2上进行修改时，我们直接将值进行+=即可，然后同时递归两棵树合并即可；也可以重新new一棵新树，将两棵树结点相加赋给新树即可。

方法二：迭代
迭代解决本题使用栈和队列都可以，这里我们以队列进行讨论：
（1）当root1结点不为空，且root2结点不为空时，我们将root2结点值累加给root1结点值；
（2）当root1结点为空，root2结点不为空或者root1结点不为空，root2结点为空时，我们可以进行合并，统一条件为if(!node1 && node2)，也就是说当root1结点为空时，直接将root2结点赋给root1即可，但不对(node1 && !node2)处理是因为在上面条件下，我们将直接跳过该情况，root1不为空而root2为空，不用改变root1结点值，直接进行后续操作。

● 代码实现

方法一：递归

/**
 * 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) return root2;
        if(!root2) 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;
    }
};

方法二：迭代

/**
 * 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) return root2;
        if(!root2) return root1;

        queue<TreeNode*> que;

        que.push(root1);
        que.push(root2);

        while(!que.empty())
        {
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();

            node1->val += node2->val;

            if(node1->left && node2->left)
            {
                que.push(node1->left);
                que.push(node2->left);
            }

            if(node1->right && node2->right)
            {
                que.push(node1->right);
                que.push(node2->right);
            }

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

            if(!node1->right && node2->right)
            {
                node1->right = node2->right;
            }
        }
        return root1;
    }
};

● Leetcode700 二叉搜索树中的搜索

题目链接：Leetcode700 二叉搜索树中的搜索
视频讲解：代码随想录|二叉搜索树中的搜索
题目描述：给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]
示例 2:

输入：root = [4,2,7,1,3], val = 5
输出：[]

● 解题思路

关于二叉搜索树，二叉搜索树是一个有序树：
·若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
·若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
·它的左、右子树也分别为二叉搜索树。

递归/迭代
基于二叉搜索树的特性，递归和迭代解决二叉搜索树的思路相同：
（1）遍历结点值大于目标值时，若目标结点存在必然在左子树；
（2）遍历结点值小于目标值时，若目标结点存在必然在右子树；
（3）否则，二叉搜索树中不存在与目标值相等的结点。

● 代码实现

方法一：递归

/**
 * 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(!root || root->val == val) return root;

        TreeNode* result = nullptr;
        if(root->val > val) result = searchBST(root->left, val);
        if(root->val < val) result = searchBST(root->right, val);

        return result;
    }
};

方法二：迭代

/**
 * 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) {

        while(root)
        {
            if(root->val > val) root = root->left;
            else if(root->val < val) root = root->right;
            else return root;
        }
        return nullptr;
    }
};

● Leetcode98 验证二叉搜索树

题目链接：Leetcode98 验证二叉搜索树
视频讲解：代码随想录|验证二叉搜索树
题目描述：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

输入：root = [2,1,3]
输出：true
示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

● 解题思路

方法一：暴力求解
根据二叉搜索树的特地，中序遍历结果所得数组的元素递增，因此可以中序遍历将元素值存储在vector中，遍历数组元素判断是否为二叉搜索树；

方法二：递归
因为二叉搜索树的判断不能单独判断左结点小于中结点，右结点大于中结点即为二叉搜索树，对于示例二中的情况可以进行解释。
因此需要使用pre保存最大值，保证结点中序递增；

方法三：迭代
使用中序迭代可以对二叉搜索树进行判断。

● 代码实现

方法一：暴力求解
TIPS：在遍历数组的时候需要注意数组越界的情况

/**
 * 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> vec;
    void traversal(TreeNode* root)
    {
        if(!root) return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
    bool isValidBST(TreeNode* root) {
        traversal(root);
        for(int i = 1; i < vec.size(); i++)
        {
            if(vec[i] <= vec[i - 1])
            {
                return false;
            }
        }
        return true;
    }
};

方法二：递归

/**
 * 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* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if(!root) return true;

        //左
        bool left = isValidBST(root->left);
        //中
        if(pre && pre->val >= root->val) return false;
        pre = root;
        //右
        bool right = isValidBST(root->right);

        return left && right;
    }
};

方法三：迭代

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL; // 记录前一个节点
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;                // 左
            } else {
                cur = st.top();                 // 中
                st.pop();
                if (pre != NULL && cur->val <= pre->val)
                return false;
                pre = cur; //保存前一个访问的结点

                cur = cur->right;               // 右
            }
        }
        return true;
    }
};