530.二叉搜索树的最小绝对差
文档讲解：代码随想录.二叉搜索树的最小绝对差
视频讲解：二叉搜索树中，需要掌握如何双指针遍历！| LeetCode：530.二叉搜索树的最小绝对差
状态：已完成
代码实现
cpp
/**
* 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) {}
* };
*/
/**
* 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 {
private:
// vector<int> nums;
// void travsersl(TreeNode* root) {
// if (root == nullptr) {
// return;
// }
// travsersl(root->left);
// nums.push_back(root->val);
// travsersl(root->right);
// }
int result = INT_MAX;
TreeNode* pre = nullptr;
void travsersl(TreeNode* cur) {
if (cur == nullptr) {
return;
}
travsersl(cur->left);
if (pre != nullptr) {
result = min(result, cur->val - pre->val);
}
pre = cur;
travsersl(cur->right);
}
public:
int getMinimumDifference(TreeNode* root) {
// 第一种方法
// nums.clear();
// travsersl(root);
// int result = INT_MAX;
// for (int i = 1; i < nums.size(); i++) {
// result = result > (nums[i] - nums[i - 1]) ? nums[i] - nums[i - 1]
// : result;
// }
// return result;
// 第二种方法
travsersl(root);
return result;
}
};心得体会
- 有序二叉树采用中序遍历进行数据的读取，可以先转换成数组，再进行后续的操作，
- 遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。
- 同时要学会在递归遍历的过程中如何记录前后两个指针，这也是一个小技巧，学会了还是很受用的。
501. 二叉搜索树中的众数
文档讲解：代码随想录.二叉搜索树中的众数
视频讲解：不仅双指针，还有代码技巧可以惊艳到你！ | LeetCode：501.二叉搜索树中的众数
状态：已完成
代码实现
cpp
/**
* 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 {
private:
int count = 0;
int count_max = 0;
vector<int> result;
TreeNode* pre = NULL;
void searshBST(TreeNode* cur) {
if (cur == NULL) {
return;
}
searshBST(cur->left); // 左中右遍历
if (pre == NULL) {//这里的判断条件理解错误，应该是第一次走的时候的逻辑
count = 1;
} else if (pre->val == cur->val) {
count++;
} else {
count = 1;
}
pre = cur;
if (count == count_max) {
result.push_back(cur->val);
}
if (count > count_max) {
count_max = count;
result.clear();
result.push_back(cur->val);
}
searshBST(cur->right);
return;
}
public:
vector<int> findMode(TreeNode* root) {
count = 0;
count_max = 0;
pre = NULL;
result.clear();
searshBST(root);
return result;
}
};心得体会
- 在第一次写的时候，忽略了第一次走循环的判断条件，导致调试失败
- 另外本文还以后另外两种方法，需要花时间仔细品味一下
236. 二叉树的最近公共祖先
文档讲解：代码随想录.二叉树的最近公共祖先
视频讲解：自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先
状态：已完成
代码实现
cpp
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
// 中止条件
if (root == p || root == q || root == NULL) {
return root;
}
TreeNode* left = lowestCommonAncestor(root->left, p, q);
TreeNode* right = lowestCommonAncestor(root->right, p, q);
if (left != NULL && right != NULL) {
return root;
}//这个条件遗漏了
if (left == NULL && right != NULL) {
return right;
} else if (left != NULL && right == NULL) {
return left;
} else { // left ==NULL right == NULL
return NULL;
}
}
};心得体会
- 目前来说根据视频可以理解，也可以通过记忆进行复现，但是总感觉有地方没有吃透，需要自己进行适当的整理和总结
- 注意事项
那么二叉树如何可以自底向上查找呢？
回溯啊，二叉树回溯的过程就是从低到上。
后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。