10 May 2025•Easy•C++ / Python / TypeScript

Convert Sorted Array to Binary Search Tree

build balanced bst from sorted array by recursively using middle element as root.

recursively: pick middle element as root, left half becomes left subtree, right half becomes right subtree. this ensures balanced tree.

base case: empty array returns null. the middle element naturally creates a balanced structure since we split evenly.

complexity

O(n) time to visit each element once, O(log n) space for recursion stack. balanced tree height is log n.

Solution files

Python•convert-sorted-array-to-binary-search-tree/solution.py

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        total_nums = len(nums)
        if not total_nums:
            return None

        mid_node = total_nums // 2
        return TreeNode(
            nums[mid_node], 
            self.sortedArrayToBST(nums[:mid_node]), self.sortedArrayToBST(nums[mid_node + 1 :])
        )

Python•convert-sorted-array-to-binary-search-tree/synced-solution.py

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def buildBST(left, right):
            if left > right:
                return None
            mid = (left + right) // 2
            root = TreeNode(nums[mid])
            root.left = buildBST(left, mid - 1)
            root.right = buildBST(mid + 1, right)
            return root
        return buildBST(0, len(nums) - 1)

C++•convert-sorted-array-to-binary-search-tree/synced-solution.cpp

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return buildBST(nums, 0, nums.size() - 1);
    }
private:
    TreeNode* buildBST(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 = buildBST(nums, left, mid - 1);
        root->right = buildBST(nums, mid + 1, right);
        return root;
    }
};

TypeScript•convert-sorted-array-to-binary-search-tree/synced-solution.ts

function sortedArrayToBST(nums: number[]): TreeNode | null {
    function buildBST(left: number, right: number): TreeNode | null {
        if (left > right) return null;
        const mid = Math.floor((left + right) / 2);
        const root = new TreeNode(nums[mid]);
        root.left = buildBST(left, mid - 1);
        root.right = buildBST(mid + 1, right);
        return root;
    }
    return buildBST(0, nums.length - 1);
}