文章目录
- 654.最大二叉树
- [617. 合并二叉树](#617. 合并二叉树)
- 700.二叉搜索树中的搜索
- 98.验证二叉搜索树
654.最大二叉树
文章链接：654.最大二叉树
视频链接：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树
状态：又是构建二叉树！感觉过程跟之前是一样的，不断得切割数组，但是感觉代码工程量浩大，根本写不出来
思路
首先老生常谈，用什么遍历方式来构建二叉树呢？
凡事构造二叉树类的题目，都要用前序遍历，因为前序遍历是中左右，我们只有先构造出根结点，才能去构造左右子树！
伪代码
- 确定递归函数的参数和返回值：题目要求返回根结点，我们直接返回TreeNode*
cpp
TreeNode* contruct(nums){
}- 确定递归的终止条件：如果数组的大小等于1，那就说明我们已经到叶子结点了，那么构造完叶子结点，我们当然可以返回了。
cpp
//这里不考虑数组为空，因为题目保证了数组是大于等于1的
if (nums.size() == 1){
return new TreeNode(nums[0]); //数组中唯一的那一个元素就是我们的叶子结点了
}- 单层递归的逻辑：我们不仅要找到数组的最大值，还要找到它的下标
cpp
//-----------------------------构造中结点---------------------//
//将最大值设置为0，因为我们数组中的元素都是正数
int MaxValue = 0;//最大值
int Index = 0; //最大值的下标
for (int i = 0; i < nums.size; i++){
if (nums[i] > MaxValue){
MaxValue = nums[i];
Index = i;
}
node = new TreeNode(MaxValue); //构造出我们的根结点
}
//----------------------------- 构造左结点-------------------//
//构造左子树，我们要先分割数组，并且要保证数组的左子集至少要有一个元素
if (Index > 0){ //左区间至少有一个元素，因为我们的递归终止条件要求了nums.size == 1才能return
//切割数组
newVec(0, index);//新数组在我们数组里的下标是0~index，左闭右开的构造
node->left = contract(newVec); //开始遍历数组的左子集
}
//----------------------------构造右结点--------------------//
if (Index < nums.size - 1){//保证右区间大于等于1
newVec(index + 1, nums.size);
node->right = contract(newVec);
}
return node; //返回的node就是我们根据数组所构建的最大二叉树的根结点的指针优化代码
其实上述代码还是比较冗余的，并且效率较低。
因为我们每次都构造结点的时候我们都构造了一个新的数组。构造新数组本来就是很耗时的，所以我们每次操作下标即可，没必要构造新的数组。
CPP代码
cpp
# 这里展示的是优化后的代码
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());
}
};617. 合并二叉树
文章讲解：617. 合并二叉树
视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树
状态：我觉得这是一种构建二叉树的变式，只不过之前是操作数组来构建，这次是操作两个二叉树来构建。但是具体怎么写呢？肯定使用前序遍历；那么如何统一遍历指针的步调呢？
回答：使用前序遍历，本质上我们只对值进行操作，所以统一步调非常简单，完全不用考虑tree2比tree1少了非常多结点的情况，因为我们只操作了结点的值而不操作指针，所以一合并，会带上整棵子树的
思路
答案确实，前序遍历是最合适的，符合我们直观上合并二叉树的过程
伪代码
- 确定递归函数的参数和返回值:我们要返回合并后二叉树的根结点；然后关于参数，就是传入两个待操作的二叉树。
cpp
TreeNode* mergeTree(TreeNode* t1, TreeNode* t2){
}-
确定终止条件：
- 如果我们Tree1所遍历的结点遇到NULL，我们应该返回Tree2在对应位置的结点
- 如果我们Tree2所遍历的结点遇到NULL，我们应该返回Tree1在对应位置的结点
- 以上两个条件保证了我们同步遍历的要求！
cppif (t1 == NULL) return t2; if (t2 == NULL) return t1; //这段代码也包含了t1, t2同时为空就return NULL的情况 -
单层递归条件：
- 直接在t1上面改。单层递归中就是要把两棵树的值加到一起
cppt1->val += t2->val;- 合并t1左子树和t2左子树之后的左子树
cppt1->left = mergeTrees(t1->left, t2->left); t1->right = mergeTrees(t1->right, t2->right); return t1;
CPP代码
cpp
class Solution {
public:
TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
// 修改了t1的数值和结构
t1->val += t2->val; // 中
t1->left = mergeTrees(t1->left, t2->left); // 左
t1->right = mergeTrees(t1->right, t2->right); // 右
return t1;
}
};改变遍历顺序
本题中，中序和后序遍历也都是可以的。只要吗单层递归逻辑的代码顺序改一下就好了。为什么三种遍历方法都行呢？我感觉很主要的原因就是我们只操作值，不操作地址。
定义新二叉树
不修改树的结构进行前序遍历，代码如下：
cpp
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;
}
};700.二叉搜索树中的搜索
文章讲解：700.二叉搜索树中的搜索
视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索
状态：没学之前蒙蔽的一，学完之后简单的一
搜索树的特性
就是根结点比左子树的结点值都要大，比右子树的结点值都要小。并且其子树也符合同样的特性。
思路
在二叉搜索树中自带顺序，所以我们不需要强调前中后序
递归法代码
-
确定返回值和参数
- 关于返回值：我们要找到待搜索到树然后返回其结点即可
- 参数：传入搜索树，和要搜索的值
cppTreeNode* search (TreeNode* root, int val){ } -
确定终止条件
- 如果遍历的点是空的话，直接return root（这里传入root是因为这个root就是null）
- 或者说如果root->val == val，我们也要把结点返回。
cppif (root == NULL || root->val == val) return root; -
单层递归的逻辑
cpp
TreeNode* result = NULL; //该变量用来存放递归函数的返回值
//----------------搜索过程：由于二叉搜索树自带特性，所以我们搜索过程也根据其特性来-----------
if (val < root->val){ //如果要搜索的值小于root->val，说明要搜索的值在左子树中
result = search(root->left, val); //向左遍历时我们找到了目标值用result来接这个结果
}
if (val > root->val){
result = search(root->right, val);
}
return result; //如果都没有搜索这里返回NULL，如果搜到了返回搜到的结果即可迭代法代码
cpp
while (root != NULL){
//如果root不为空，就让root一直往下遍历
if (val < root->val) root = root->left; //往左
else if (val > root0>val) root = root->right; //往右
else return root root; //搜索到喽
}
return NULL;CPP代码
cpp
// 递归一：
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) {
if (root == NULL || root->val == val) return root;
if (root->val > val) return searchBST(root->left, val);
if (root->val < val) return searchBST(root->right, val);
return NULL;
}
};
//迭代：
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
while (root != NULL) {
if (root->val > val) root = root->left;
else if (root->val < val) root = root->right;
else return root;
}
return NULL;
}
};98.验证二叉搜索树
文章讲解：98.验证二叉搜索树
视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树
状态：如何验证，重点就是抓住如何验证？这里我们也要抓住一个重要特征：二叉搜索树在中序遍历下，输出的数值是一个有序的序列
思路
中序遍历下，输出的二叉搜索树节点的数值是有序序列。
有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。
中序遍历+判断递增
cpp
class Solution {
private:
vector<int> vec;
void traversal(TreeNode* root) {
if (root == NULL) return;
traversal(root->left);
vec.push_back(root->val); // 将二叉搜索树转换为有序数组
traversal(root->right);
}
public:
bool isValidBST(TreeNode* root) {
vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
traversal(root);
for (int i = 1; i < vec.size(); i++) {
// 注意要小于等于，搜索树里不能有相同元素
if (vec[i] <= vec[i - 1]) return false;
}
return true;
}
};边递归边判断有序
思路陷阱1
不能单纯的比较左结点小于中间结点，右结点大于中间结点。因为我们要比较的是左子树所有结点都小于于中间结点，右子树所有结点都大雨中间结点。
思路陷阱2
样例中的最小结点，有可能是int的最小值。如果这样的话我们必须初始化比较元素为longlong的最小值。
-
确定递归函数，返回值以及参数
- 初始化比较元素为longlong的最小值（全局变量）
- 递归函数有bool类型的返回值（只有寻找某一条边/某一个结点的时候，我们就要有bool类型的返回值）：本题我们在寻找一个不符合条件的结点，如果没有找到这个结点就要遍历整棵树，如果找到部分和的结点需要立刻返回。
cpplong long maxVal = LONG_MIN; bool isValidBST(TreeNode* root) -
确定终止条件
- 空结点也可以是二叉搜索树
cppif (root == NULL) return true; -
确定单层递归的逻辑
中序遍历，一直更新maxVal，一旦发现maxVal >= root ->val，立刻返回false，注意元素相同的时候也要返回false
cpp
bool left = isValidBST(root->left); //左
//中序遍历，验证遍历的元素是不是从小到大
if (maxVal < root->val) maxVal = root->val; //中
else return false;
bool right = isValidBST(root->right); //右
return left && right;- 完整代码
cpp
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;
}
};
//如果测试用例有longlong的最小事咋整？那就不初始化最小值，我们直接取到最左面结点的数值来进行比较
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;
}
};迭代法
cpp
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;
}
};