669. 修剪二叉搜索树

如果结点的值小于 low，那么说明该结点及它的左子树都不符合要求，我们返回对它的右结点进行修剪后的结果；如果结点的值大于 high，那么说明该结点及它的右子树都不符合要求，我们返回对它的左子树进行修剪后的结果；如果结点的值位于区间 [low,high]，我们将结点的左结点设为对它的左子树修剪后的结果，右结点设为对它的右子树进行修剪后的结果。

递归法

class Solution {
public:TreeNode* trimBST(TreeNode* root, int low, int high) {if (root == nullptr) return root;if (root->val < low){return trimBST(root->right, low, high);}else if (root->val > high){return trimBST(root->left, low, high);}else {root->left = trimBST(root->left, low, high);root->right = trimBST(root->right, low, high);return root;}}
};

迭代法

class Solution {
public:TreeNode* trimBST(TreeNode* root, int L, int R) {if (!root) return nullptr;// 处理头结点，让root移动到[L, R] 范围内，注意是左闭右闭while (root != nullptr && (root->val < L || root->val > R)) {if (root->val < L) root = root->right; // 小于L往右走else root = root->left; // 大于R往左走}TreeNode *cur = root;// 此时root已经在[L, R] 范围内，处理左孩子元素小于L的情况while (cur != nullptr) {while (cur->left && cur->left->val < L) {cur->left = cur->left->right;}cur = cur->left;}cur = root;// 此时root已经在[L, R] 范围内，处理右孩子大于R的情况while (cur != nullptr) {while (cur->right && cur->right->val > R) {cur->right = cur->right->left;}cur = cur->right;}return root;}
};

108. 将有序数组转换为二叉搜索树

递归版本一

class Solution {
public:TreeNode* sortedArrayToBST(vector<int>& nums) {if (nums.size() == 0) return nullptr;//把中间的下标作为根节点int rootIndex = nums.size() / 2;TreeNode* root = new TreeNode(nums[rootIndex]);int size = nums.size();//左子树的递归，左闭右开vector<int> left = vector<int>(nums.begin(), nums.begin() + rootIndex);//右子树的递归，左闭右开vector<int> right = vector<int>(nums.begin() + rootIndex + 1, nums.end());root->left = sortedArrayToBST(left);root->right = sortedArrayToBST(right);return root;}
};

递归版本二

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;}
};

迭代法

迭代法可以通过三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标。

class Solution {
public: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. 把二叉搜索树转换为累加树

中序遍历+双指针

定义一个栈，中序遍历二叉搜索树，将树节点压入栈，然后定义双指针来更新每个节点的值

class Solution {
public: void inorder(TreeNode* root, stack<TreeNode*> &stk) {if (root == nullptr) return;inorder(root->left, stk);stk.push(root);inorder(root->right, stk);}TreeNode* convertBST(TreeNode* root) {if (root == NULL) return root;stack<TreeNode*> stk;inorder(root, stk);TreeNode* next = stk.top();stk.pop();while (!stk.empty()){TreeNode* cur = stk.top();stk.pop();cur->val += next->val;next = cur;}return root;}
};

注：1.一开始只是想到用栈存储节点的值，导致后续更新节点的值的时候，对节点的操作不对，一直超时。后来看了别人的解法才知道直接存储节点更容易更新节点的值。

2.inorder中的stack要用引用传递，不能用值传递，或者直接将stack定义为全局变量。

值传递（x）、地址传递（*x）、引用传递（&x）的区别

值传递：传值其实就是一个操作副本的概念，我们在传递参数时，会将实参的副本复制到形参中。形参在函数内的修改不会影响实参。

#include <iostream>void modifyValue(int x) {x = 20;  // 只是修改了副本，不影响原始数据
}int main() {int a = 10;modifyValue(a);std::cout << "a: " << a << std::endl;  // 输出仍然是10return 0;
}

地址传递：指针可以理解为是指向变量存储位置的一个箭头，通过传递指针，将实参的地址传递给形参。形参在函数内的修改会直接影响实参。

#include <iostream>void modifyValue(int *x) {*x = 20;  // 修改了实参的值
}int main() {int a = 10;modifyValue(&a);std::cout << "a: " << a << std::endl;  // 输出是20return 0;
}

引用传递：引用传递的不是副本，也不是地址，而是指定的那个变量。通过传递引用，将实参的引用传递给形参。形参在函数内的修改会直接影响实参。

#include <iostream>void modifyValue(int &x) {x = 20;  // 修改了实参的值
}int main() {int a = 10;modifyValue(a);std::cout << "a: " << a << std::endl;  // 输出是20return 0;
}

反序中序递归

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;}
};

迭代法

class Solution {
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;}
};