第六章 二叉树 part06
今日内容
● 654.最大二叉树
● 617.合并二叉树
● 700.二叉搜索树中的搜索
● 98.验证二叉搜索树
详细布置
654.最大二叉树
【链接】（文章，视频，题目）
又是构造二叉树，昨天大家刚刚做完 中序后序确定二叉树，今天做这个 应该会容易一些， 先看视频，好好体会一下 为什么构造二叉树都是 前序遍历
题目链接/文章讲解：代码随想录
视频讲解：https://www.bilibili.com/video/BV1MG411G7ox
【第一想法与实现（困难）】
- 目意思的递归方法，前序遍历，中左右
【看后想法】
-
不重新构造vector，传参开始结束的下标
-
用数组构造二叉树的题目，尽量不要定义新的数组，而是传递数组下标索引即可，节省时间空间开销
-
注意递归函数的树结点是否允许空结点进入递归，对应的递归终止条件不同，递归调用的判断条件不同（if非空才调用递归）
【实现困难】
【自写代码】
class Solution {
public:
// 简化递归，复用函数
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
// 根据题目意思的递归方法，前序遍历中左右
// 结束条件
if (nums.empty()) {
return nullptr;
}
// 找到最大元素和对应下标，构造根节点
int max_val(INT_MIN), max_idx(-1);
for (int i = 0; i < nums.size(); ++i) {
if (nums[i] > max_val) {
max_val = nums[i];
max_idx = i;
}
}
TreeNode* root = new TreeNode(max_val);
// 判断有无孩子
if (nums.size() == 1) {
return root;
}
// 切割左右子树，左闭右开
vector<int> left_nums(nums.begin(), nums.begin() + max_idx);
vector<int> right_nums(nums.begin() + max_idx + 1, nums.end());
// 递归获得左右孩子
root->left = constructMaximumBinaryTree(left_nums);
root->right = constructMaximumBinaryTree(right_nums);
return root;
}
};
class Solution {
public:
TreeNode* ConstructMaximumBinaryTree(const vector<int>& nums, int begin, int end) {
// 结束条件
if (begin >= end || begin < 0 || end > nums.size()) {
return nullptr;
}
// 获取最大值和下标，构造根节点
int max_val(INT_MIN), max_idx(-1);
for (int i = begin; i < end; ++i) {
if (nums[i] > max_val) {
max_val = nums[i];
max_idx = i;
}
}
TreeNode* root = new TreeNode(max_val);
// 判断有左右孩子
if (end - begin == 1) {
return root;
}
// 切割左右子树，左闭右开
int left_begin(begin), left_end(max_idx);
int right_begin(max_idx + 1), right_end(end);
// 递归获得左右孩子
root->left = ConstructMaximumBinaryTree(nums, left_begin, left_end);
root->right = ConstructMaximumBinaryTree(nums, right_begin, right_end);
return root;
}
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
return ConstructMaximumBinaryTree(nums, 0, nums.size());
}
};
【收获与时长】1h
617.合并二叉树
【链接】（文章，视频，题目）
这次是一起操作两个二叉树了， 估计大家也没一起操作过两个二叉树，也不知道该如何一起操作，可以看视频先理解一下。 优先掌握递归。
题目链接/文章讲解：代码随想录
视频讲解：https://www.bilibili.com/video/BV1m14y1Y7JK
【第一想法与实现（困难）】
- 递归，单层逻辑：中左右，合并本个结点，合并左子树，合并右子树
【看后想法】
【实现困难】
【自写代码】
class Solution {
public:
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
// 结束条件，至少有一个为空
if (!root1 && !root2) {
return nullptr;
}
if (!root1 && root2) {
return root2;
}
if (root1 && !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;
}
};
class Solution {
public:
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
// 迭代方法，利用第一棵树
std::queue<TreeNode*> que;
if (!root1) {
return root2;
}
if (!root2) {
return root1;
}
// 1,2都非空才加入队列
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;
// 访问
// 都非空，入队
// 1非空2空，已经满足，不需要操作
// 1空2非空，把2赋值给1
// 左
if (node1->left && node2->left) {
que.push(node1->left);
que.push(node2->left);
}
if (!node1->left && node2->left) {
node1->left = node2->left;
}
// 右
if (node1->right && node2->right) {
que.push(node1->right);
que.push(node2->right);
}
if (!node1->right && node2->right) {
node1->right = node2->right;
}
}
return root1;
}
};
【收获与时长】1h
700.二叉搜索树中的搜索
【链接】（文章，视频，题目）
递归和迭代 都可以掌握以下，因为本题比较简单， 了解一下 二叉搜索树的特性
题目链接/文章讲解: 代码随想录
视频讲解：https://www.bilibili.com/video/BV1wG411g7sF
【第一想法与实现（困难）】
- 直接递归，比较简单，利用二叉搜索树的性质
【看后想法】
【实现困难】
【自写代码】
class Solution {
public:
// 递归，直接
TreeNode* searchBST(TreeNode* root, int val) {
// 结束条件
if (!root) {
return nullptr;
}
// 单层逻辑
if (val < root->val) {
return searchBST(root->left, val);
}
if (val > root->val) {
return searchBST(root->right, val);
}
return root;
}
};
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
// 迭代
TreeNode* cur = root;
while (cur) {
if (val < cur->val) {
cur = cur->left;
} else if (val > cur->val) {
cur = cur->right;
} else { // 找到了
return cur;
}
}
return nullptr;
}
};
【收获与时长】10m
98.验证二叉搜索树
【链接】（文章，视频，题目）
遇到 搜索树，一定想着中序遍历，这样才能利用上特性。
但本题是有陷阱的，可以自己先做一做，然后在看题解，看看自己是不是掉陷阱里了。这样理解的更深刻。
题目链接/文章讲解：代码随想录
视频讲解：https://www.bilibili.com/video/BV18P411n7Q4
【第一想法与实现（困难）】
【看后想法】
-
利用中序遍历有序的特性，递归方法，构造中序遍历数组
-
递归方法，不需要真的生成数组，只要在原来要插入的位置，对比前值有序即可。递归可以合并成复用的函数
-
迭代方法，中序遍历，对比前值
【实现困难】
【自写代码】
class Solution {
public:
void InorderTraverse(TreeNode* node, std::vector<int>* vec_ptr) {
// 终止条件
if (!node) {
return;
}
// 单层逻辑，中序遍历，左中右
InorderTraverse(node->left, vec_ptr);
vec_ptr->emplace_back(node->val);
InorderTraverse(node->right, vec_ptr);
}
bool isValidBST(TreeNode* root) {
if (!root) {
return true;
}
// 利用中序遍历有序的特性
std::vector<int> vec;
InorderTraverse(root, &vec);
for (int i = 1; i < vec.size(); ++i) {
if (vec[i - 1] >= vec[i]) {
return false;
}
}
return true;
}
};
class Solution {
public:
// 不需要真的生成数组，只要在原来要插入的位置，对比前值即可
TreeNode* pre = nullptr;
bool isValidBST(TreeNode* root) {
// 终止条件
if (!root) {
return true;
}
// 左中右
bool is_left = isValidBST(root->left);
if (pre && pre->val >= root->val) {
return false;
}
pre = root;
bool is_right = isValidBST(root->right);
return is_left && is_right;
}
};
class Solution {
public:
bool isValidBST(TreeNode* root) {
// 迭代方法，中序遍历，同时使用栈和指针
// 指针，正在遍历访问；栈，已经访问等待处理
// 处理的操作：对比前值
TreeNode* pre = nullptr;
TreeNode* cur = root;
std::stack<TreeNode*> st;
while (cur || !st.empty()) {
if (cur) { // 一路向左访问
st.push(cur);
cur = cur->left;
} else { // 取栈顶并处理
cur = st.top();
st.pop();
if (pre && pre->val >= cur->val) {
return false;
}
pre = cur;
// 处理完中，访问右
cur = cur->right;
}
}
return true;
}
};
【收获与时长】1h40m
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
