Introduction

In this blog post, we will explore how to solve the LeetCode problem "897" 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 the root of a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child. Example 1: Input: root = [5,3,6,2,4,null,8,1,null,null,null,7,9] Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9] Example 2: Input: root = [5,1,7] Output: [1,null,5,null,7] Constraints: The number of nodes in the given tree will be in the range [1, 100]. 0 <= Node.val <= 1000

Explanation

Here's a solution to the problem:

• In-order Traversal: Perform an in-order traversal of the binary search tree to extract all the node values in ascending order.

• Reconstruct Tree: Create a new binary tree using the extracted node values, where each node has only a right child, effectively forming a linked list structure. The leftmost node (smallest value) becomes the new root.

• Time and Space Complexity: O(N) time complexity, where N is the number of nodes in the tree, and O(N) space complexity due to the in-order traversal potentially storing all node values. A tail-recursion optimized version avoids the O(N) space complexity from stack usage.

Code

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

def increasingBST(root):
    """
    Rearranges a binary search tree into an in-order linked list with only right children.

    Args:
        root: The root of the binary search tree.

    Returns:
        The root of the new linked list.
    """

    def in_order(node):
        if not node:
            return []
        return in_order(node.left) + [node.val] + in_order(node.right)

    values = in_order(root)
    new_root = TreeNode(values[0])
    current = new_root
    for i in range(1, len(values)):
        current.right = TreeNode(values[i])
        current = current.right
    return new_root