Return the root node of a binary search tree that matches the given preorder traversal.
(Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value <node.val, and any descendant of node.right has a value >node.val. Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.)
We are given the root node of a maximum tree: a tree where every node has a value greater than any other value in its subtree.
Just as in the previous problem, the given tree was constructed from an 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 value A[i].
The left child of root will be Construct([A, A, ..., A[i-1]])
The right child of root will be Construct([A[i+1], A[i+2], ..., A[A.length - 1]])
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.
Input: root = [4,1,3,null,null,2], val = 5
Explanation: A = [1,4,2,3], B = [1,4,2,3,5]
Input: root = [5,2,4,null,1], val = 3
Explanation: A = [2,1,5,4], B = [2,1,5,4,3]
Input: root = [5,2,3,null,1], val = 4
Explanation: A = [2,1,5,3], B = [2,1,5,3,4]
1 <= B.length <= 100
Since val is the last element of the array, we compare root->val with val, if root->val > val then val can be inserted into the right subtree recursively, otherwise, root will be the left subtree of val.
Segment tree is a balanced binary tree with O(logn) height given n input segments. Segment tree supports fast range query O(logn + k), and update O(logn). Building such a tree takes O(n) time if the input is an array of numbers.