算法刷题day18|二叉树：669. 修剪二叉搜索树、108. 将有序数组转换为二叉搜索树、538. 把二叉搜索树转换为累加树

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;  // 输出仍然是10
    return 0;
}

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

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

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

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