108. Convert Sorted Array to Binary Search Tree

Converting a sorted array into a height-balanced binary search tree is a classic problem frequently asked at companies like Google, and Microsoft. It tests your understanding of divide-and-conquer recursion and the properties of binary search trees, making it an essential pattern to master for technical interviews.

Problem statement

You are given an integer array nums containing elements sorted in ascending order. Your task is to construct a height-balanced binary search tree (BST) from this array.

A height-balanced binary search tree is a binary tree in which the difference in heights between the left and right subtrees of any node is at most 1.

Note that multiple valid balanced BSTs can exist for the same input array.

Constraints:

• 1 <= nums.length <= 10⁴
• -10⁴ <= nums[i] <= 10⁴
• nums is sorted in a strictly increasing order.

Examples

Intutition

The key intuition is that our input is already sorted. For a three-element sorted array, the middle element becomes the root, with the first as the left child and the third as the right child, automatically creating a balanced BST.

Optimized approach using recursion

We extend this through recursive subdivision: select the middle element as the current node, then recursively build the left subtree from the left half and the right subtree from the right half. Choosing the middle ensures that both subtrees have roughly equal numbers of nodes, guaranteeing balance.

As the array is sorted, elements to the left of the middle element are automatically smaller, and elements to the right are larger; the sorted order ensures the BST property, while middle-element selection ensures balance.

This approach works with any values (negative, positive, mixed) because we rely on positioning, not absolute values. The recursive divide-and-conquer naturally maintains balance by building symmetrically from the center outward.

Step-by-step algorithm

Helper Method sortedArrayToBstHelper(nums, low, high): A recursive helper function that builds the binary search tree from a segment of the sorted array. This function takes the nums array along with low and high indexes that define the current subarray range.

1. If low is greater than high, return None as no elements remain in the current range representing an empty subtree.
2. Calculate the middle index by setting mid = low + (high - low) // 2.
3. Initialize root as a new TreeNode with nums[mid] as its data.
4. Build the left subtree by recursively calling sortedArrayToBstHelper with the range (low, mid - 1) and assign the returned subtree to root.left.
5. Build the right subtree by recursively calling sortedArrayToBstHelper with range (mid + 1, high) and assign the returned subtree to root.right.
6. Return the root node of the constructed subtree, so it can be linked to its parent node in the recursion chain.

sortedArrayToBST(nums): This function initiates the BST construction process. This invokes the helper function sortedArrayToBstHelper with the complete array range by passing nums, 0 as the starting index, and len(nums) - 1 as the ending index, and returns the root node of the fully constructed height-balanced BST.

To better understand the solution, let’s walk through the algorithm using the illustration below:

1 / 9

Code implementation

Let’s look at the code for the solution we just discussed.

class TreeNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None


def sortedArrayToBstHelper(nums, low, high):
    # Base case: no elements in this range
    if low > high:
        return None
    
    # Calculate middle index to ensure balance
    # Using low + (high - low) // 2 avoids potential overflow
    mid = low + (high - low) // 2
    
    # Create root node with middle element
    root = TreeNode(nums[mid])
    
    # Recursively build left subtree from left half
    root.left = sortedArrayToBstHelper(nums, low, mid - 1)
    
    # Recursively build right subtree from right half
    root.right = sortedArrayToBstHelper(nums, mid + 1, high)
    
    return root


def sortedArrayToBST(nums):
    return sortedArrayToBstHelper(nums, 0, len(nums) - 1)


def level_order_traversal(root):
    """Helper function to serialize tree for output display"""
    if not root:
        return []
    
    result = []
    queue = [root]
    
    while queue:
        node = queue.pop(0)
        if node:
            result.append(node.data)
            queue.append(node.left)
            queue.append(node.right)
        else:
            result.append(None)
    
    # Remove trailing None values for cleaner output
    while result and result[-1] is None:
        result.pop()
    
    return result


def main():
    test_cases = [
        [11, 22, 33, 44, 55, 66, 77, 88],
        [25, 50, 75, 100, 125, 350],
        [1, 2, 3],
        [1, 2, 3, 4],
        [-10, -3, 0, 5, 9]
    ]
    
    for i, nums in enumerate(test_cases, 1):
        print(f"{i}.\tInput:  {nums}")
        root = sortedArrayToBST(nums)
        output = level_order_traversal(root)
        print(f"\tOutput: {output}")
        print("-" * 75)


if __name__ == '__main__':
    main()

Time complexity

The time complexity of this algorithm is O(n) where n represents the number of elements in the input array. We create exactly one tree node for each element in the array, visiting each element precisely once during the recursive construction process.

Space complexity

The space complexity is O(log n) for the recursion call stack in the average case where the tree is balanced. As we’re constructing a height-balanced BST, the maximum depth of our recursive calls equals the height of the tree, which is logarithmic (log n) for a balanced binary tree containing n nodes.

Common pitfalls and interview tips

1. Integer overflow in middle calculation: Using mid = (low + high) // 2 can cause integer overflow in languages like Java or C++ when low and high are both large values. Always use the safer formula mid = low + (high - low) // 2 to avoid this issue. While Python handles large integers automatically, using the safer formula demonstrates best practices and awareness of potential edge cases.
2. Confusing node attribute names: The provided solution uses TreeNode.data instead of the more common TreeNode.val. Make sure you’re consistent with your node class definition throughout your implementation. Mixing attribute names like using node.data in one place and node.val in another will cause runtime errors that can be difficult to debug during an interview.