随想录一刷Day23——二叉树

Day23_二叉树

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

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

将一个有序数组转化为二叉搜索树，每次选择中间的元素作为根节点，左右递归构造子树即可形成平衡二叉搜索树。
由于区间为偶数时，中间元素有两种选择，所以答案不唯一

递归法

class Solution {
private:
    TreeNode* traversal(vector<int> &nums, int left, int right) {
    	// [left, right]
        if (left > right) return NULL;
        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) {
        queue<TreeNode*> nodeQue; // 存放节点
        queue<int> leftQue; // 存放区间左边界
        queue<int> rightQue; // 存放区间右边界
        TreeNode* root = new TreeNode(0);
        nodeQue.push(root);
        leftQue.push(0);
        rightQue.push(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];
            // 左子树
            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;
    }
};

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

538. 把二叉搜索树转换为累加树
思路：

由于右子树中的节点值均大于根节点，左子树中的节点值均小于根节点，于是当遍历顺序为 右->中->左 ，累加结点值即可

递归法

class Solution {
public:
    int sum = 0;
    TreeNode* convertBST(TreeNode* root) {
        if (root == NULL) return NULL;
        if (root->right) convertBST(root->right);
        sum += root->val;
        root->val = sum;
        if (root->left) convertBST(root->left);
        return root;
    }
};

迭代法

class Solution {
public:
    int sum = 0;
    TreeNode* convertBST(TreeNode* root) {
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        int sum = 0;
        while (cur || !stk.empty()) {
            if (cur) {
                stk.push(cur); // 压栈用于回溯
                cur = cur->right;    // 右
            } else {
                cur = stk.top(); stk.pop(); // 中
                sum += cur->val;
                cur->val = sum;

                cur = cur->left; // 左
            }
        }
        return root;
    }
};