二叉树
669 修改二叉搜索树 medium
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。
题中已经提到，不可以修改树中元素的相对结构，所以此前通过移动二叉树某部分的方法在此题中不适用。
首先要找到结点数值在[low, high]之间的值要删除的结点，这个点就是我们最终要返回的根节点。而难处理的点无非两种情况：
- 值比Low小，但有比它值大的右子树，
- 值比High大，但有比它值小的左子树
这两种情况下，就需要做处理，让子树直接替换被删除结点的位置就可以了
所以，按照这个处理逻辑，我们先来用迭代法解决这道题，代码如下：
TreeNode* trimBST(TreeNode* root, int low, int high) {
if (root == nullptr) return nullptr;
while (root != nullptr && (root->val < low || root->val > high)) {
if (root->val < low) {
root = root->right;
} else root = root->left;
}
TreeNode* cur = root;
while (cur != nullptr) {
while (cur->left != nullptr && cur->left->val < low)
cur->left = cur->left->right;
cur = cur->left;
}
cur = root;
while (cur != nullptr) {
while (cur->right != nullptr && cur->right->val > high)
cur->right = cur->right->left;
cur = cur->right;
}
return root;
}
而如果使用递归法，思路也是一样的，会更简洁一些，此处借鉴随想录中的代码：
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;
}
108 将有序数组转换为二叉搜索树 easy
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
此前有过根据后序/前序 + 中序构造二叉树的题目，
也有过将二叉搜索树转换为数组解决问题的题目
如果要构造高度平衡的二叉搜索树，必然要从中间结点出发，划分分割点，然后逐步递归寻找分割点。
递归法的返回类型为结点，传入参数要有原数组和分割后的数组边界
终止条件即分割数组中没有值
单次递归的遍历逻辑有，先找到中间结点，然后分割区间，用于构建当前结点的左右子树，整体代码如下：
TreeNode* reversal(vector<int>& nums, int left, int right) {
if (left > right) return nullptr;
int mid = (left + right) >> 1;
TreeNode* root = new TreeNode(nums[mid]);
root->left = reversal(nums, left, mid - 1);
root->right = reversal(nums, mid + 1, right);
return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
TreeNode* root = reversal(nums, 0 ,nums.size() - 1);
return root;
}
而迭代法则较为复杂一点，因为要构造三个序列存放遍历的结点，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标，代码借鉴代码随想录，如下所示：
TreeNode* sortedArrayToBST(vector<int>& nums) {
if (nums.size() == 0) return nullptr;
TreeNode* root = new TreeNode(0); // 初始根节点
queue<TreeNode*> nodeQue; // 放遍历的节点
queue<int> leftQue; // 保存左区间下标
queue<int> rightQue; // 保存右区间下标
nodeQue.push(root); // 根节点入队列
leftQue.push(0); // 0为左区间下标初始位置
rightQue.push(nums.size() - 1); // nums.size() - 1为右区间下标初始位置
while (!nodeQue.empty()) {
TreeNode* curNode = nodeQue.front();
nodeQue.pop();
int left = leftQue.front(); leftQue.pop();
int right = rightQue.front(); rightQue.pop();
int mid = left + ((right - left) / 2);
curNode->val = nums[mid]; // 将mid对应的元素给中间节点
if (left <= mid - 1) {
// 处理左区间
curNode->left = new TreeNode(0);
nodeQue.push(curNode->left);
leftQue.push(left);
rightQue.push(mid - 1);
}
if (right >= mid + 1) {
// 处理右区间
curNode->right = new TreeNode(0);
nodeQue.push(curNode->right);
leftQue.push(mid + 1);
rightQue.push(right);
}
}
return root;
}
538 把二叉搜索树转换为累加树 medium
给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：
- 节点的左子树仅包含键 小于 节点键的节点。
- 节点的右子树仅包含键 大于 节点键的节点。
- 左右子树也必须是二叉搜索树。
根据示例图可以看出来，遍历顺序应该是从右到左，即反中序遍历（右中左），记录前一个结点的值，然后累加当前结点的值即可。
返回类型为空，因为最终要返回根结点，遇到空结点返回；单层处理逻辑是，先往右遍历，然后当前结点先加上上一个结点的值，上个结点更替为当前结点，然后再往左遍历。
代码如下：
int pre = 0;
void reversal(TreeNode* cur) {
if (cur == nullptr) return;
reversal(cur->right);
cur->val += pre;
pre = cur->val;
reversal(cur->left);
}
TreeNode* convertBST(TreeNode* root) {
if (root == nullptr) return nullptr;
reversal(root);
return root;
}
而如果使用迭代法，直接使用中序遍历就好，此处参考代码随想录：
private:
int pre; // 记录前一个节点的数值
void traversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* cur = root;
while (cur != NULL || !st.empty()) {
if (cur != NULL) {
st.push(cur);
cur = cur->right; // 右
} else {
cur = st.top(); // 中
st.pop();
cur->val += pre;
pre = cur->val;
cur = cur->left; // 左
}
}
}
public:
TreeNode* convertBST(TreeNode* root) {
pre = 0;
traversal(root);
return root;
}