代码随想录训练营第二十三天——修剪二叉搜索树，将有序数组转换为二叉搜索树，二叉搜索树转化为累加树

leetcode 669. 修剪二叉搜索树

题目链接：修剪二叉搜索树

递归法：

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (root == NULL ) return NULL;  //空节点直接返回空节点
        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;
    }
};

迭代法：

在剪枝的时候，分为下三步：

• 将root移动到[L, R] 范围内，注意是左闭右闭区间
• 剪枝左子树
• 剪枝右子树

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

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

题目链接：将有序数组转换为二叉搜索树
本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间。
分割点就是数组中间位置的节点，如果遇到要处理的数组是偶数，中间位置两个数，固定取左边的数。

递归法：

class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int left, int right)  //递归的区间设定为左闭右闭区间
    {
        if (left > right) return NULL; //左闭右闭区间，所以终止条件是left>right
        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 NULL;
        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;
    }
};

leetcode 538. 把二叉搜索树转换为累加树

题目链接：二叉搜索树转换为累加树
二叉搜索树相当于从小到大排序的有序数组，将数组从后到前累加即可。
所以在二叉搜索树中累加的顺序就是右中左，所以通过反中序遍历二叉树，然后顺序累加及可。

递归法：

不需要递归函数的返回值，要遍历整棵树；定义一个int型的全局变量pre，用来保存cur节点的前一个节点的数值。

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