# Solving Leetcode Interviews in Seconds with AI: Maximum Binary Tree II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "998" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), 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
	> A maximum tree is a tree where every node has a value greater than any other value in its subtree. You are given the root of a maximum binary tree and an integer val. Just as in the previous problem, the given tree was constructed from a list a (root = Construct(a)) recursively with the following Construct(a) routine:  If a is empty, return null. Otherwise, let a[i] be the largest element of a. Create a root node with the value a[i]. The left child of root will be Construct([a[0], a[1], ..., a[i - 1]]). The right child of root will be Construct([a[i + 1], a[i + 2], ..., a[a.length - 1]]). Return root.  Note that we were not given a directly, only a root node root = Construct(a). Suppose b is a copy of a with the value val appended to it. It is guaranteed that b has unique values. Return Construct(b).   Example 1:   Input: root = [4,1,3,null,null,2], val = 5 Output: [5,4,null,1,3,null,null,2] Explanation: a = [1,4,2,3], b = [1,4,2,3,5]  Example 2:   Input: root = [5,2,4,null,1], val = 3 Output: [5,2,4,null,1,null,3] Explanation: a = [2,1,5,4], b = [2,1,5,4,3]  Example 3:   Input: root = [5,2,3,null,1], val = 4 Output: [5,2,4,null,1,3] Explanation: a = [2,1,5,3], b = [2,1,5,3,4]    Constraints:  The number of nodes in the tree is in the range [1, 100]. 1 <= Node.val <= 100 All the values of the tree are unique. 1 <= val <= 100  

	# Explanation
	Here's the solution to the problem:

*   **Key Idea:** The core idea is to traverse the existing tree and find the correct position to insert the new value `val`. Since `val` is appended to the original array, it will be the last element considered when building the new tree. We traverse down the right subtree until we find a node whose value is smaller than `val`.
*   **Insertion:** When we find such a node, we make the current node the left child of the new node with value `val`. The original right subtree of the current node becomes the right child of the new node.
*   **Root Replacement:** If the value `val` is greater than the current root, the current root becomes the left child of the new node, and the new node becomes the new root of the tree.

*   **Complexity:**
    *   Runtime: O(H), where H is the height of the tree. In the worst case, H can be N (number of nodes). So O(N)
    *   Storage: O(1) - iterative approach consumes constant extra space

	
	# Code
	```python
	# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode:
        new_node = TreeNode(val)

        if not root:
            return new_node

        if val > root.val:
            new_node.left = root
            return new_node

        current = root
        while current.right and current.right.val > val:
            current = current.right

        new_node.left = current.right
        current.right = new_node

        return root
	```