二叉树
红黑树就是一种二叉平衡搜索树，这两个树不是独立的，所以C++中map、multimap、set、multiset的底层实现机制是二叉平衡搜索树，再具体一点是红黑树
二叉树的递归遍历
递归，三要素
-
确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
-
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
-
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
确定递归函数的参数和返回值：
void traversal(TreeNode* cur, vector<int>& vec)
终止条件
if (cur == NULL) return;
确定单层递归的逻辑：前序遍历是中左右的顺序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：
vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
#### **递归栈模拟**/*
- 栈帧展开：每次递归调用生成一个栈帧，保存当前节点状态。
- 回溯机制：当左子树递归到底（如叶子节点）后，自动返回上一层处理右子树
*/
前序遍历：
class Solution {
public:void traversal(TreeNode* cur, vector<int>& vec) {if (cur == NULL) return;vec.push_back(cur->val); // 中traversal(cur->left, vec); // 左traversal(cur->right, vec); // 右/*traversal(cur->left, vec); // 左traversal(cur->right, vec); // 右vec.push_back(cur->val); // 中*//*traversal(cur->left, vec); // 左vec.push_back(cur->val); // 中traversal(cur->right, vec); // 右*/}}vector<int> preorderTraversal(TreeNode* root) {vector<int> result;traversal(root, result);return result;}
};
- 144.二叉树的前序遍历(opens new window)
- 145.二叉树的后序遍历(opens new window)
- 94.二叉树的中序遍历
二叉树的迭代遍历
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中
前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，取出栈顶元素,然后将右孩子加入栈，再加入左孩子。
为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序
vector<int> preorderTraversal(TreeNode* root) {stack<TreeNode*>st;vector<int>result;if (root == NULL) return result;st.push(root);while(!st.empty()){TreeNode* node = st.top(); st.pop();result.push_back(node->val);if (node->right) st.push(node->right); if (node->left) st.push(node->left);}return result;}
中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的
在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素
| 特性 | 递归 | 非递归（栈模拟） |
|---|---|---|
| 适用场景 | 树深度较小时 | 避免栈溢出风险（如深度大的树） |
层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑
这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上
102. 二叉树的层序遍历 - 力扣（LeetCode）
# 递归法
class Solution {
public:void order(TreeNode* cur, vector<vector<int>>& result, int depth){if (cur == nullptr) return;if (result.size() == depth) result.push_back(vector<int>());result[depth].push_back(cur->val);order(cur->left, result, depth + 1);/*depth += 1;order(cur->left, result, depth);depth -= 1;*/order(cur->right, result, depth + 1);}vector<vector<int>> levelOrder(TreeNode* root) {vector<vector<int>> result;int depth = 0;order(root, result, depth);return result;}
};
翻转二叉树
只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果
前中后序遍历，还是层序遍历
前序遍历和后序遍历,层序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次(左中右 左翻转过了,中时会把左变右,递归右时实际是又翻转了左)
那要让中序可以的呢
那么用栈来实现，因为这是用栈来遍历，而不是靠指针来遍历，避免了递归法中翻转了两次的情况
226. 翻转二叉树 - 力扣（LeetCode）
前序遍历（根→左→右）
核心特性：优先处理根节点，自上而下访问，适合需要先获取父节点信息的场景
中序遍历（左→根→右）
核心特性：左根右顺序，特别适配二叉搜索树（BST）
后序遍历（左→右→根）
核心特性：自下而上处理，适合需要先获取子树结果的场景
层序遍历（广度优先）
核心特性：按层级横向扫描，适合处理与深度或层级相关的问题
对称二叉树
遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中
101. 对称二叉树 - 力扣（LeetCode）
class Solution {
public:bool compare(TreeNode* left, TreeNode* right) {// 首先排除空节点的情况if (left == NULL && right != NULL) return false;else if (left != NULL && right == NULL) return false;else if (left == NULL && right == NULL) return true;// 排除了空节点，再排除数值不相同的情况else if (left->val != right->val) return false;// 此时就是：左右节点都不为空，且数值相同的情况// 此时才做递归，做下一层的判断bool outside = compare(left->left, right->right); // 左子树：左、 右子树：右bool inside = compare(left->right, right->left); // 左子树：右、 右子树：左bool isSame = outside && inside; // 左子树：中、 右子树：中 （逻辑处理）return isSame;}bool isSymmetric(TreeNode* root) {if (root == NULL) return true;return compare(root->left, root->right);}
};
二叉树的最大深度
使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度
而根节点的高度就是二叉树的最大深度
class Solution {
public:int getdepth(TreeNode* node) {if (node == NULL) return 0;int leftdepth = getdepth(node->left); // 左int rightdepth = getdepth(node->right); // 右int depth = 1 + max(leftdepth, rightdepth); // 中return depth;}int maxDepth(TreeNode* root) {return getdepth(root);}
};
/*
class Solution {
public:int maxDepth(TreeNode* root) {if (root == null) return 0;return 1 + max(maxDepth(root->left), maxDepth(root->right));}
};
*/
二叉树的最小深度
使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度
class Solution {
public:int getDepth(TreeNode* node) {if (node == NULL) return 0;int leftDepth = getDepth(node->left); // 左int rightDepth = getDepth(node->right); // 右// 中// 当一个左子树为空，右不为空，这时并不是最低点if (node->left == NULL && node->right != NULL) { return 1 + rightDepth;} // 当一个右子树为空，左不为空，这时并不是最低点if (node->left != NULL && node->right == NULL) { return 1 + leftDepth;}int result = 1 + min(leftDepth, rightDepth);return result;}int minDepth(TreeNode* root) {return getDepth(root);}
};
完全二叉树的节点个数
// 版本一
class Solution {
private:int getNodesNum(TreeNode* cur) {if (cur == NULL) return 0;int leftNum = getNodesNum(cur->left); // 左int rightNum = getNodesNum(cur->right); // 右int treeNum = leftNum + rightNum + 1; // 中return treeNum;}
public:int countNodes(TreeNode* root) {return getNodesNum(root);}
};
代码精简之后C++代码如下：
// 版本二
class Solution {
public:int countNodes(TreeNode* root) {if (root == NULL) return 0;return 1 + countNodes(root->left) + countNodes(root->right);}
};
迭代
那么只要模板少做改动，加一个变量result，统计节点数量就可以了
平衡二叉树
求深度可以从上到下去查 所以需要前序遍历（中左右），
而高度只能从下到上去查，所以只能后序遍历（左右中）
int leftHeight = getHeight(node->left); // 左
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right); // 右
if (rightHeight == -1) return -1;int result;
if (abs(leftHeight - rightHeight) > 1) { // 中result = -1;
} else {result = 1 + max(leftHeight, rightHeight); // 以当前节点为根节点的树的最大高度
}return result;
根节点的高度就是这棵树的最大深度，所以才可以使用后序遍历
递归
二叉树的所有路径
257. 二叉树的所有路径 - 力扣（LeetCode）
从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径
-
直接拼接字符串：合并循环内外的字符串操作：
string str; for (int val : path) {str += (str.empty() ? "" : "->") + to_string(val); }使用更高效的方法
-
流式操作：通过
ostringstream减少临时字符串生成ostringstream oss; for (int i = 0; i < path.size(); i++) {oss << path[i] << (i < path.size()-1 ? "->" : ""); } result.push_back(oss.str());
```cpp
// 版本一
class Solution {
private:void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {path.push_back(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中 // 这才到了叶子节点if (cur->left == NULL && cur->right == NULL) {string sPath;for (int i = 0; i < path.size() - 1; i++) {sPath += to_string(path[i]);sPath += "->";}sPath += to_string(path[path.size() - 1]);result.push_back(sPath);return;}if (cur->left) { // 左 traversal(cur->left, path, result);path.pop_back(); // 回溯}if (cur->right) { // 右traversal(cur->right, path, result);path.pop_back(); // 回溯}}public:vector<string> binaryTreePaths(TreeNode* root) {vector<string> result;vector<int> path;if (root == NULL) return result;traversal(root, path, result);return result;}
};
左叶子之和
404. 左叶子之和 - 力扣（LeetCode）
首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。
class Solution {
public:int sumOfLeftLeaves(TreeNode* root) {if (root == NULL) return 0;if (root->left == NULL && root->right== NULL) return 0;int leftValue = sumOfLeftLeaves(root->left); // 左if (root->left && !root->left->left && !root->left->right) { // 左子树就是一个左叶子的情况leftValue = root->left->val;}int rightValue = sumOfLeftLeaves(root->right); // 右int sum = leftValue + rightValue; // 中return sum;}
};
因为不能判断本节点是不是左叶子节点。
此时就要通过节点的父节点来判断其左孩子是不是左叶子了。
平时通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性
路径总和
112. 路径总和 - 力扣（LeetCode）
如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值
如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。
如果要搜索其中一条符合条件的路径，那么递归一定需要返回值
class Solution {
private:bool traversal(TreeNode* cur, int count) {if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回if (cur->left) { // 左count -= cur->left->val; // 递归，处理节点;if (traversal(cur->left, count)) return true;count += cur->left->val; // 回溯，撤销处理结果}if (cur->right) { // 右count -= cur->right->val; // 递归，处理节点;if (traversal(cur->right, count)) return true;count += cur->right->val; // 回溯，撤销处理结果}return false;}public:bool hasPathSum(TreeNode* root, int sum) {if (root == NULL) return false;return traversal(root, sum - root->val);}
};
精简之后如下：
class Solution {
public:bool hasPathSum(TreeNode* root, int sum) {if (!root) return false;if (!root->left && !root->right && sum == root->val) {return true;}return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);}
};
从中序与后序遍历序列构造二叉树
106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素
class Solution {
private:// 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {if (postorderBegin == postorderEnd) return NULL;int rootValue = postorder[postorderEnd - 1];TreeNode* root = new TreeNode(rootValue);if (postorderEnd - postorderBegin == 1) return root;int delimiterIndex;for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {if (inorder[delimiterIndex] == rootValue) break;}// 切割中序数组// 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)int leftInorderBegin = inorderBegin;int leftInorderEnd = delimiterIndex;// 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)int rightInorderBegin = delimiterIndex + 1;int rightInorderEnd = inorderEnd;// 切割后序数组// 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)int leftPostorderBegin = postorderBegin;int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size// 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);return root;}
public:TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {if (inorder.size() == 0 || postorder.size() == 0) return NULL;// 左闭右开的原则return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());}
};
确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭
105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）
前序和中序可以唯一确定一棵二叉树。
后序和中序可以唯一确定一棵二叉树。
前序和后序不能唯一确定一棵二叉树！，因为没有中序遍历无法确定左右部分，也就是无法分割。
学会打日志来调试（如何打日志有时候也是个技术活），不要脑动模拟，脑动模拟很容易越想越乱。
最大二叉树
654. 最大二叉树 - 力扣（LeetCode）
构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。
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;// 分割点下标：maxValueIndexint 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. 合并二叉树 - 力扣（LeetCode）
如何同时遍历两个二叉树呢？
其实和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作
class Solution {
public:TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2if (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;}
};
二叉搜索树中的搜索
二叉搜索树是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
700. 二叉搜索树中的搜索 - 力扣（LeetCode）
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;}
};
验证二叉搜索树
98. 验证二叉搜索树 - 力扣（LeetCode）
中序遍历下，输出的二叉搜索树节点的数值是有序序列。
有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了
递归法
可以递归中序遍历将二叉搜索树转变成一个数组
然后只要比较一下，这个数组是否是有序的，注意二叉搜索树中不能有重复元素
递归遍历的过程中直接判断是否有序
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; //中/*if (pre != NULL && pre->val < root->val) return true; //不行*/pre = root; // 记录前一个节点bool right = isValidBST(root->right); //右return left && right;}
};
- 陷阱1
不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了
我们要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点
二叉搜索树的最小绝对差
注意是二叉搜索树，二叉搜索树可是有序的。
遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值
最直观的想法，就是把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值了。
其实在二叉搜素树中序遍历的过程中，我们就可以直接计算了. 需要用一个pre节点记录一下cur节点的前一个节点
class Solution {
private:
int result = INT_MAX;
TreeNode* pre = NULL;
void traversal(TreeNode* cur) {if (cur == NULL) return;traversal(cur->left); // 左if (pre != NULL){ // 中result = min(result, cur->val - pre->val);}pre = cur; // 记录前一个traversal(cur->right); // 右
}
public:int getMinimumDifference(TreeNode* root) {traversal(root);return result;}
};
二叉搜索树中的众数
如果不是二叉搜索树，
最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合
既然是搜索树，
它中序遍历就是有序的
使用了pre指针和cur指针
弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较
class Solution {
private:int maxCount = 0; // 最大频率int count = 0; // 统计频率TreeNode* pre = NULL;vector<int> result;void searchBST(TreeNode* cur) {if (cur == NULL) return ;searchBST(cur->left); // 左// 中if (pre == NULL) { // 第一个节点count = 1;} else if (pre->val == cur->val) { // 与前一个节点数值相同count++;} else { // 与前一个节点数值不同count = 1;}pre = cur; // 更新上一个节点if (count == maxCount) { // 如果和最大值相同，放进result中result.push_back(cur->val);}if (count > maxCount) { // 如果计数大于最大值频率maxCount = count; // 更新最大频率result.clear(); // 很关键的一步，不要忘记清空result，之前result里的元素都失效了result.push_back(cur->val);}searchBST(cur->right); // 右return ;}public:vector<int> findMode(TreeNode* root) {count = 0;maxCount = 0;pre = NULL; // 记录前一个节点result.clear();searchBST(root);return result;}
};
应该是先遍历一遍数组，找出最大频率（maxCount），然后再重新遍历一遍数组把出现频率为maxCount的元素放进集合。（因为众数有多个）
频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了
二叉树的最近公共祖先
236. 二叉树的最近公共祖先 - 力扣（LeetCode）
遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了
回溯，二叉树回溯的过程就是从底到上。
后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。
class Solution {
public:TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {if (root == q || root == p || 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;}}
};
递归函数有返回值就是要遍历某一条边
搜索一条边的写法：
if (递归函数(root->left)) return ;
if (递归函数(root->right)) return ;
搜索整个树写法：
left = 递归函数(root->left); // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理; // 中
二叉搜索树的最近公共祖先
235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）
本题是二叉搜索树，二叉搜索树是有序的
因为是有序树，所以 如果 中间节点是 q 和 p 的公共祖先，那么 中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p
所以当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[q, p]区间中，那么cur就是 q和p的最近公共祖先
class Solution {
private:TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {if (cur == NULL) return cur;// 中if (cur->val > p->val && cur->val > q->val) { // 左TreeNode* left = traversal(cur->left, p, q);if (left != NULL) {return left;}}if (cur->val < p->val && cur->val < q->val) { // 右TreeNode* right = traversal(cur->right, p, q);if (right != NULL) {return right;}}return cur;}
public:TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {return traversal(root, p, q);}
};
二叉搜索树中的插入操作
701. 二叉搜索树中的插入操作 - 力扣（LeetCode）
class Solution {
public:TreeNode* insertIntoBST(TreeNode* root, int val) {if (root == NULL) {TreeNode* node = new TreeNode(val);return node;}if (root->val > val) root->left = insertIntoBST(root->left, val);if (root->val < val) root->right = insertIntoBST(root->right, val);return root;}
};
递归函数不用返回值也可以，找到插入的节点位置，直接让其父节点指向插入节点，结束递归，也是可以的
class Solution {
private:TreeNode* parent;void traversal(TreeNode* cur, int val) {if (cur == NULL) {TreeNode* node = new TreeNode(val);if (val > parent->val) parent->right = node;else parent->left = node;return;}parent = cur;if (cur->val > val) traversal(cur->left, val);if (cur->val < val) traversal(cur->right, val);return;}public:TreeNode* insertIntoBST(TreeNode* root, int val) {parent = new TreeNode(0);if (root == NULL) {root = new TreeNode(val);}traversal(root, val);return root;}
};
删除二叉搜索树中的节点
450. 删除二叉搜索树中的节点 - 力扣（LeetCode）
class Solution {
public:TreeNode* deleteNode(TreeNode* root, int key) {if (root == nullptr) return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了if (root->val == key) {// 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点if (root->left == nullptr && root->right == nullptr) {///! 内存释放delete root;return nullptr;}// 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点else if (root->left == nullptr) {auto retNode = root->right;///! 内存释放delete root;return retNode;}// 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点else if (root->right == nullptr) {auto retNode = root->left;///! 内存释放delete root;return retNode;}// 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置// 并返回删除节点右孩子为新的根节点。else {TreeNode* cur = root->right; // 找右子树最左面的节点while(cur->left != nullptr) {cur = cur->left;}cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置TreeNode* tmp = root; // 把root节点保存一下，下面来删除root = root->right; // 返回旧root的右孩子作为新rootdelete tmp; // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）return root;}}if (root->val > key) root->left = deleteNode(root->left, key);if (root->val < key) root->right = deleteNode(root->right, key);return root;}
};
修剪二叉搜索树
669. 修剪二叉搜索树 - 力扣（LeetCode）
class Solution {
public:TreeNode* trimBST(TreeNode* root, int low, int high) {if (root == nullptr ) return nullptr;if (root->val < low) {TreeNode* right = trimBST(root->right, low, high); // 寻找符合区间[low, high]的节点return right;}if (root->val > high) {TreeNode* left = trimBST(root->left, low, high); // 寻找符合区间[low, high]的节点return left;}root->left = trimBST(root->left, low, high); // root->left接入符合条件的左孩子root->right = trimBST(root->right, low, high); // root->right接入符合条件的右孩子return root;}
};
修剪操作
通过递归或迭代逐层判断节点是否在区间内：
-
若节点值在区间外，直接舍弃该子树的一部分（如节点值小于
low，则递归处理右子树） -
若节点值在区间内，继续处理其左右子树
二叉搜索树是有序的
将有序数组转换为二叉搜索树
108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）
class Solution {
private:TreeNode* traversal(vector<int>& nums, int left, int right) {if (left > right) return nullptr;int mid = left + ((right - left) / 2);TreeNode* root = new TreeNode(nums[mid]);root->left = traversal(nums, left, mid - 1);root->right = traversal(nums, mid + 1, right);return root;}
public:TreeNode* sortedArrayToBST(vector<int>& nums) {TreeNode* root = traversal(nums, 0, nums.size() - 1);return root;}
};
把二叉搜索树转换为累加树
538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）
*换一个角度来看，这就是一个有序数组[2, 5, 13]，求从后到前的累加数组，也就是[20, 18, 13]，是不是感觉这就简单了。
从树中可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了
class Solution {
private:int pre = 0; // 记录前一个节点的数值void traversal(TreeNode* cur) { // 右中左遍历if (cur == NULL) return;traversal(cur->right); //右cur->val += pre; //中pre = cur->val;traversal(cur->left); //左}
public:TreeNode* convertBST(TreeNode* root) {pre = 0;traversal(root);return root;}
};
-
涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。
-
求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。
-
求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了。
二叉树：找所有路径 (opens new window)用了前序，这是为了方便让父节点指向子节点。
所以求普通二叉树的属性还是要具体问题具体分析。
![[Pasted image 20250413233248.png]]