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).

&nbsp;
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]


&nbsp;
Constraints:


	The number of nodes in the tree is in the range [1, 100].
	1 &lt;= Node.val &lt;= 100
	All the values of the tree are unique.
	1 &lt;= val &lt;= 100


class Solution:
    """
    approach:
    given a, we can get the inorder traversal of it, then append val to it and
    then construct the tree back
    """
    def insertIntoMaxTree(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        inorder_list = []
        def inorder(root):
            if not root:
                return
            inorder(root.left)
            inorder_list.append(root.val)
            inorder(root.right)
            
        inorder(root)
        inorder_list.append(val)
        
        def get_maximum(val_list):
            max_index = -1
            max_val = -1
            for i, val in enumerate(val_list):
                if val > max_val:
                    max_val = val
                    max_index = i
            return max_index, max_val
                
        def create_tree(val_list):
            if not len(val_list):
                return None
            index, val = get_maximum(val_list)
            node = TreeNode(val)
            node.left = create_tree(val_list[:index])
            node.right = create_tree(val_list[index+1:])
            return node
        
        b = create_tree(inorder_list)
        return b
class Solution {
    public TreeNode insertIntoMaxTree(TreeNode root, int val) {
        if (root==null) return new TreeNode(val);
        if (val > root.val) {
            TreeNode newRoot = new TreeNode(val);
            newRoot.left = root;
            return newRoot;
        }
        root.right = insertIntoMaxTree(root.right, val);
        return root;
    }
}
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    void insertIntoMaxTreeRec(TreeNode* root,TreeNode* newNode)//o(logn)
    {

        if(!root)
            return;
        if(root->right&&root->right->val<newNode->val)
        {
            newNode->left=root->right;
            root->right=newNode;

            return;

        }
        if(!root->right)
        {root->right=newNode;

        return;}

         insertIntoMaxTreeRec( root->right, newNode);

    }
    TreeNode* insertIntoMaxTree(TreeNode* root, int val) {
         TreeNode* curr=new TreeNode(val);

        if(root->val<val)
        {
            curr->left=root;
            root=curr;
        }else
        {
              insertIntoMaxTreeRec( root, curr);

        }
        return root;

    }
};
/**
 * @param {TreeNode} root
 * @param {number} val
 * @return {TreeNode}
 */
var insertIntoMaxTree = function(root, val) {
    // get new node
    var node = new TreeNode(val);

    // no root
    if(!root) {
        return node;
    }

    // upward derivation if val larger then root
    if(val > root.val) {
        return node.left = root, node;
    }

    // downward derivation
    root.right = insertIntoMaxTree(root.right, val);

    // root construct
    return root;
};
Maximum Binary Tree II