LeetCode - 108/109. Convert Sorted Array/List to Binary Search Tree

108. Convert Sorted Array to Binary Search Tree

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

dfs解决，每次找到数组中间的点，构建子树。时间复杂度O(n)，空间复杂度O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (nums.empty()) return NULL;
        int len = nums.size();
        TreeNode* node = solve(nums, 0, len - 1);
        return node;
    }
    TreeNode* solve(vector<int>& nums, int le, int ri) {
        if (le > ri) return NULL;
        int mid = (le + ri) >> 1;
        TreeNode* node = new TreeNode(nums[mid]);
        node->left = solve(nums, le, mid - 1);
        node->right = solve(nums, mid + 1, ri);
        return node;
    }
};

109. Convert Sorted List to Binary Search Tree

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

跟上题思路一样，dfs解决。不过这里由于是一个链表，无法直接获取链表的中间值，所以我们假设对构建的树进行中根遍历，那么在左子树构建完后，当前结点的值就是此刻根节点的值。时间复杂度O(n)，空间复杂度O(n)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* list;
    TreeNode* sortedListToBST(ListNode* head) {
        if (!head) return NULL;
        int len = 0;
        ListNode* tail = head;
        while (tail) {
            len++;
            tail = tail->next;
        }
        this->list = head;
        TreeNode* ans = solve(0, len - 1);
        return ans;
    }
    TreeNode* solve(int le, int ri) {
        if (le > ri) return NULL;
        int mid = (le + ri) >> 1;
        TreeNode* node = new TreeNode(0);
        node->left = solve(le, mid - 1);
        node->val = list->val;
        list = list->next;
        node->right = solve(mid + 1, ri);
        return node;
    }
};