day20 | 654.最大二叉树、 617.合并二叉树、 700.二叉搜索树中的搜索、98.验证二叉搜索树
目录：
链接
题目链接：
https://leetcode.cn/problems/maximum-binary-tree/
https://leetcode.cn/problems/merge-two-binary-trees/
https://leetcode.cn/problems/search-in-a-binary-search-tree/
解题及思路学习
654. 最大二叉树
给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
- 创建一个根节点，其值为
nums中的最大值。 - 递归地在最大值 左边 的 子数组前缀上 构建左子树。
- 递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 nums 构建的 最大二叉树 。
示例 1：
!https://assets.leetcode.com/uploads/2020/12/24/tree1.jpg
输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
思考：跟昨天最后一道题有点像。先从数组中找到最大值，然后根据该值将数组划分为左右两个分区间。重复这个递归过程，返回的应该是一个指针。
听完视频之后写的代码：
(要点：注意要返回的是节点指针，在递归过程中要使用new 来创建内存）
class Solution {
public:
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
if (nums.size() == 1) {
return new TreeNode(nums[0]);
}
int max_index = 0;
for (int i = 0; i < nums.size(); i++) {
if (nums[i] > nums[max_index]) {
max_index = i;
}
}
TreeNode* node = new TreeNode(nums[max_index]);
vector<int> leftnums(nums.begin(), nums.begin() + max_index);
vector<int> rightnums(nums.begin() + max_index + 1, nums.end());
if (max_index > 0) {
node->left = constructMaximumBinaryTree(leftnums);
}
if (max_index < nums.size()-1) {
node->right = constructMaximumBinaryTree(rightnums);
}
return node;
}
};
随想录代码：
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;
}
};
//优化版本代码
class Solution {
private:
// 在左闭右开区间[left, right)，构造二叉树
TreeNode* traversal(vector<int>& nums, int left, int right) {
if (left >= right) return nullptr;
// 分割点下标：maxValueIndex
int maxValueIndex = left;
for (int i = left + 1; i < right; ++i) {
if (nums[i] > nums[maxValueIndex]) maxValueIndex = i;
}
TreeNode* root = new TreeNode(nums[maxValueIndex]);
// 左闭右开：[left, maxValueIndex)
root->left = traversal(nums, left, maxValueIndex);
// 左闭右开：[maxValueIndex + 1, right)
root->right = traversal(nums, maxValueIndex + 1, right);
return root;
}
public:
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
return traversal(nums, 0, nums.size());
}
};
优化后的代码，用下标去表示区间，就不用每次都去重新创建，所以效率会高很多。
注意类似用数组构造二叉树的题目，每次分隔尽量不要定义新的数组，而是通过下标索引直接在原数组上操作，这样可以节约时间和空间上的开销。
递归函数什么时候加if，什么时候不加if？
一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。
617.合并二叉树
给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。
示例 1：
!https://assets.leetcode.com/uploads/2021/02/05/merge.jpg
输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]
思考：好像迭代法阔以。先想一下递归方法。好像，只需要把两个root对应的位置相加，再根据新的数组来构造二叉树就可以了。
好像也不行，传入的是二叉树结构的指针，而不是数组。那就用前序递归，来构造二叉树。 ps:我刚开始想的创建额外的内存来存放新的数据，但是代码随想录这里借用了一下root1，直接返回t1修改的数据，更加省内存（秒啊）
class Solution {
public:
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
if (root1 == NULL) return root2;
if (root2 == NULL) return root1;
root1->val += root2->val;
root1->left = mergeTrees(root1->left, root2->left);
root1->right = mergeTrees(root1->right, root2->right);
return root1;
}
};
//重新定义一棵树的代码
class Solution {
public:
TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if (t1 == NULL) return t2;
if (t2 == NULL) return t1;
// 重新定义新的节点，不修改原有两个树的结构
TreeNode* root = new TreeNode(0);
root->val = t1->val + t2->val;
root->left = mergeTrees(t1->left, t2->left);
root->right = mergeTrees(t1->right, t2->right);
return root;
}
};
随想录-迭代法：
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;
}
};
700.二叉搜索树中的搜索
给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。
示例 1:
!https://assets.leetcode.com/uploads/2021/01/12/tree1.jpg
输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]
思考：这个好像还挺简单的，迭代法和递归都能做。首先去寻找节点，再返回子树。
迭代法：
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
queue<TreeNode*> que;
if (root->val == val) return root;
if (root->val != val && root != NULL) que.push(root);
TreeNode* result = NULL;
while(!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if (node->val == val) {
result = node;
break;
}
if (node->val > val && node->left) que.push(node->left);
if (node->val < val && node->right) que.push(node->right);
}
}
return result;
}
};
随想录：
二叉搜索树是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
迭代法,(迭代法我刚开始想复杂了，弄了一大堆判断），然后空指针的概念不清楚。空指针是指针变量指向内存中编号为0的空间，int * p = NULL。 空节点也就是空指针。
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* searchBST(TreeNode* root, int val) {
while(root != NULL){
if (root->val < val) root = root->right;
else if (root->val > val) root = root->left;
else {
return root;
}
}
return NULL;
}
};
这个迭代法确实思路简单！
98.验证二叉搜索树
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
- 节点的左子树只包含 小于 当前节点的数。
- 节点的右子树只包含 大于 当前节点的数。
- 所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
!https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg
输入：root = [2,1,3]
输出：true
思考：迭代法，每次都返回该分支的最大值。
自己写的递归方法，用的是后序遍历，缝缝补补，总有些过不了（错误，只考虑到了每个节点处，没考虑到两个分支的最大值和最小值是否满足条件）
‘
class Solution {
public:
bool isValidBST(TreeNode* root) {
if (root == NULL) return true;
if (!root->left && !root->right) return true;
if (!root->left && root->val < root->right->val) return true;
if (!root->right && root->val > root->left->val) return true;
if (!root->left && root->val >= root->right->val) return false;
if (!root->right && root->val <= root->left->val) return false;
bool flag = false;
bool lflag = isValidBST(root->left);
bool rflag = isValidBST(root->right);
if(lflag && rflag && (root->val > root->left->val && root->val < root->right->val)) flag = true;
return flag;
}
};
随想录：如果一棵树是二叉搜索树，那么用中序遍历的方法得到的结果也是有序的。
//看了视频之后自己写的
class Solution {
public:
TreeNode* pre = NULL;
bool isValidBST(TreeNode* root) {
if (root == NULL) return true;
bool lflag = isValidBST(root->left);
if (pre != NULL && pre->val >= root->val) {
return false;
}
pre = root;
bool rflag = isValidBST(root->right);
return lflag && rflag;
}
};
//随想录代码：
class Solution {
public:
long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
bool isValidBST(TreeNode* root) {
if (root == NULL) return true;
bool left = isValidBST(root->left);
// 中序遍历，验证遍历的元素是不是从小到大
if (maxVal < root->val) maxVal = root->val;
else return false;
bool right = isValidBST(root->right);
return left && right;
}
};
class Solution {
public:
TreeNode* pre = NULL; // 用来记录前一个节点
bool isValidBST(TreeNode* root) {
if (root == NULL) return true;
bool left = isValidBST(root->left);
if (pre != NULL && 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;
}
};
这种用两个指针比较前后的大小的方法很秒。
注意二叉搜索树的特点，用中序遍历得到的序列是有序的。
困难及收获
困难
递归把我绕麻了今天。我记得各种边界条件比较难判断。以及是否需要加if。再就是关于数据结构的基础知识，掌握了之后能更好的帮助解题。
今日收获
1、一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。
2、二叉搜索树是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
3、构造二叉树用前序遍历。二叉搜索树用中序遍历。