Introduction

In this blog post, we will explore how to solve the LeetCode problem "1008" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

Given an array of integers preorder, which represents the preorder traversal of a BST (i.e., binary search tree), construct the tree and return its root. It is guaranteed that there is always possible to find a binary search tree with the given requirements for the given test cases. A binary search tree is a binary tree where for every node, any descendant of Node.left has a value strictly less than Node.val, and any descendant of Node.right has a value strictly greater than Node.val. A preorder traversal of a binary tree displays the value of the node first, then traverses Node.left, then traverses Node.right. Example 1: Input: preorder = [8,5,1,7,10,12] Output: [8,5,10,1,7,null,12] Example 2: Input: preorder = [1,3] Output: [1,null,3] Constraints: 1 <= preorder.length <= 100 1 <= preorder[i] <= 1000 All the values of preorder are unique.

Explanation

Here's an efficient solution for constructing a BST from its preorder traversal:

• Recursive Approach: Use recursion to build the tree. The first element of the preorder array is always the root.
• Value Range: Pass a value range (lower and upper bound) down the recursive calls. This range defines the permissible values for nodes in the subtree. Elements outside this range don't belong in the current subtree.

• Subtree Construction: Find the first element in the preorder array that's greater than the current node's value. This element signifies the start of the right subtree. Recursively build the left subtree (elements between current node and right subtree start) and the right subtree (elements from the right subtree start until the end of the applicable range).

• Time Complexity: O(N), where N is the number of nodes in the tree. Each node is visited once.

• Space Complexity: O(N) in the worst case (skewed tree), due to recursion depth.

Code

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

def bstFromPreorder(preorder):
    """
    Constructs a BST from its preorder traversal.

    Args:
        preorder: A list of integers representing the preorder traversal of a BST.

    Returns:
        The root of the constructed BST.
    """

    def helper(lower=float('-inf'), upper=float('inf')):
        nonlocal pre_idx  # Allows modification of the outer scope variable

        if pre_idx == len(preorder):
            return None

        val = preorder[pre_idx]
        if val < lower or val > upper:
            return None

        pre_idx += 1
        root = TreeNode(val)
        root.left = helper(lower, val)
        root.right = helper(val, upper)
        return root

    pre_idx = 0
    return helper()