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
Solutions
Solution 1: Recursion
If $val$ is the maximum number, then make $val$ the new root node, and $root$ the left subtree of the new root node.
If $val$ is not the maximum number, since $val$ is the last appended number, it must be on the right side of $root$. Therefore, we can insert $val$ as a new node into the right subtree of $root$.
The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes in the tree.
1 2 3 4 5 6 7 8 91011121314
# 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 = rightclassSolution:definsertIntoMaxTree(self,root:Optional[TreeNode],val:int)->Optional[TreeNode]:ifrootisNoneorroot.val<val:returnTreeNode(val,root)root.right=self.insertIntoMaxTree(root.right,val)returnroot
1 2 3 4 5 6 7 8 9101112131415161718192021222324
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */classSolution{publicTreeNodeinsertIntoMaxTree(TreeNoderoot,intval){if(root==null||root.val<val){returnnewTreeNode(val,root,null);}root.right=insertIntoMaxTree(root.right,val);returnroot;}}
/** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */funcinsertIntoMaxTree(root*TreeNode,valint)*TreeNode{ifroot==nil||root.Val<val{return&TreeNode{val,root,nil}}root.Right=insertIntoMaxTree(root.Right,val)returnroot}
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */structTreeNode*insertIntoMaxTree(structTreeNode*root,intval){if(!root||root->val<val){structTreeNode*res=(structTreeNode*)malloc(sizeof(structTreeNode));res->val=val;res->left=root;res->right=NULL;returnres;}root->right=insertIntoMaxTree(root->right,val);returnroot;}
Solution 2: Iteration
Search the right subtree, find the node where $curr.val \gt val \gt curr.right.val$, then create a new node $node$, point $node.left$ to $curr.right$, and then point $curr.right$ to $node$.
Finally, return $root$.
The time complexity is $O(n)$, where $n$ is the number of nodes in the tree. The space complexity is $O(1)$.
1 2 3 4 5 6 7 8 910111213141516171819
# 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 = rightclassSolution:definsertIntoMaxTree(self,root:Optional[TreeNode],val:int)->Optional[TreeNode]:ifroot.val<val:returnTreeNode(val,root)curr=rootnode=TreeNode(val)whilecurr.rightandcurr.right.val>val:curr=curr.rightnode.left=curr.rightcurr.right=nodereturnroot
/** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */funcinsertIntoMaxTree(root*TreeNode,valint)*TreeNode{ifroot.Val<val{return&TreeNode{val,root,nil}}node:=&TreeNode{Val:val}curr:=rootforcurr.Right!=nil&&curr.Right.Val>val{curr=curr.Right}node.Left=curr.Rightcurr.Right=nodereturnroot}