代码随想录算法训练营第二十三天|108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树、669.修剪二叉搜索树

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

我的版本

• 注意到题目中要求是高度差不能大于一
• 所以可以采用类似二分法的感觉，将有序数组差分的值放到一个个节点上

class Solution {
 public:
	TreeNode *gen(const vector<int> &nums, int left, int right) {
		//想明白递归到最后究竟返回什么, 返回的是不存在的nullptr
		if (left > right)//注意是大于
			return nullptr;
		int mid = left + (right - left) / 2;
		TreeNode *root = new TreeNode(nums[mid]);
		root->left = gen(nums, left, mid);
		root->right = gen(nums, mid + 1, right);
		return root;
	}
	TreeNode *sortedArrayToBST(vector<int> &nums) {
		int left = 0;
		int right = nums.size();
		return gen(nums, left, right);
	}
};

代码随想录

递归

• 跟我的差不多

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:
	long sum;
	void traversal(TreeNode *node) {
		if (node == nullptr)return;
		traversal(node->right);
		sum += node->val;
		node->val = sum;
		traversal(node->left);
	}
	TreeNode *convertBST(TreeNode *root) {
		sum = 0;
		traversal(root);
		return root;
	}
};

代码随想录

递归

• 类似于我的

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

669.修剪二叉搜索树

我的版本

无

代码随想录

递归

• 主要是递归逻辑里，还有一层递归
• 删除这一段的时候分为两种情况
  • 这个节点小于low，那么这个节点和其左子树需要删除，但是他的右子树中，可能会有大于low需要保存的节点，所以需要再次递归（下面第6行）
  • 大于high同理，需要在左子树中递归，说不定有不用删除的
• 然后就是正常的root左右子树递归了
• 最后返回root

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

迭代法

• 因为二叉搜索树有序性质，不需要栈模拟递归的过程
• 分为三步：
  • 将root移动到[L, R] 范围内，注意是左闭右闭区间
  • 剪枝左子树
  • 剪枝右子树

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

day23结束