Editing Cartesian tree

[[File:Cartesian_tree.svg|250px|thumb|right|A sequence and its corresponding Cartesian tree]]

Given a sequence of numbers (or any [[totally ordered]] objects), there exists a [[Binary heap|binary min-heap]] whose [[inorder traversal]] is that sequence. This is known as the '''Cartesian tree''' for that sequence.

==Construction==
To see what such a tree would look like, imagine starting with the example sequence shown on the right. Because 1 is the smallest element in the sequence, it must occur at the root of the Cartesian tree (which is min-heap-ordered). Now, in an inorder traversal of the Cartesian tree, all the elements in the root's left subtree will be visited before the root, and all the elements in the right subtree after; so we can readily conclude that the elements 9, 3, and 7 occur in the left subtree, whereas 8, 12, 10, 20, 15, 18, and 5 occur in the right subtree.

To actually construct the left subtree, we apply this reasoning recursively; the left subtree of the root is itself min-heap-ordered, so its root must be the element 3, as it is the smallest of 9, 3, and 7. Likewise, the root of the right subtree must be 5, which is the smallest of all the elements to the right of the 1; and so on.

It is clear from this discussion that there always exists at least one valid Cartesian tree for any given sequence.

===Uniqueness===
Based on the technique given above to construct a Cartesian tree, and the underlying reasoning, we see that the Cartesian tree of a sequence of distinct numbers is always unique. If there are duplicates in the sequence, there may be multiple possible Cartesian trees; for example, the sequence [5, 5] has two possible Cartesian trees (one in which the root has a left child, and one in which it has a right child). On the other hand, [5, 2, 5] has only one possible Cartesian tree, even though it has duplicate elements. The precise criterion is that ''the Cartesian tree is unique if and only if every segment of the sequence has a unique minimum element''.

We can guarantee uniqueness even with duplicates by insisting that if an element appears multiple times in a sequence then the occurrence furthest to the left is always considered to be the smallest, or by finding any other way to break ties.

===Naive method===
The naive method described above may take up to <math>O(N^2)</math> time, since it requires scanning the sequence to find its minimum, then scanning the range to the left of the minimum, and scanning the range to the right, and so on down; this algorithm then has the same performance dynamics as [[quicksort]] (average <math>O(N \log N)</math>).

===Left-to-right===
The Cartesian tree may be constructed on one pass over the sequence. We proceed from left to right and add each value we encounter as a new node to the tree; after having processed the first <math>i</math> elements of the sequence, we will have a valid Cartesian tree for these initial elements. After we have processed the entire sequence (<math>i = N</math>), the Cartesian tree will be complete.

Thus, we begin by constructing a singleton tree containing only the first element <math>a_1</math> in the sequence; this is a valid Cartesian tree for the segment of the sequence containing only the first element. Then, we repeatedly examine the next element <math>a_{i+1}</math>. At each step, we keep track of <math>v_i</math>, that is, the node that has label <math>a_i</math> (the last value inserted):
* If <math>a_{i+1} \geq a_i</math>, then we just insert a new node <math>v_{i+1}</math> as the right child of <math>v_1</math>, and label this new node with <math>a_{i+1}</math>.
* Otherwise, we consider node <math>P(v_i)</math>, the parent of <math>v_i</math>. If the label of <math>P(v_i)</math> is less than or equal to <math>a_{i+1}</math>, we stop. Otherwise, we look to ''its'' parent, <math>P(P(v_i))</math>, and see whether ''its'' label is less than or equal to <math>a_{i+1}</math> and so on. If we stop at node <math>u</math>, with right child <math>w</math>, then we insert the new node <math>v_{i+1}</math> so that it is the right child of <math>u</math>, and make <math>w</math> the left child of <math>v_{i+1}</math>.
* If we trace all the way up to the root of the tree so far, and still find no node with label less than or equal to <math>a_{i+1}</math>, then <math>a_{i+1}</math> is the smallest element seen so far; so make the new node <math>v_{i+1}</math> the root of the tree, and make the old root <math>v_{i+1}</math>'s left child.

====Pseudocode====
<pre>
input sequence A with length N indexed from 1
// label the root node 1, with left child = right child = 0 (nonexistent)
root &larr; 1
left[1] &larr; 0
right[1] &larr; 0
// the root's label is the first item in the sequence
label[1] &larr; A[1]
for i &isin; [2..N]
    last &larr; i-1               // node of A[i-1]
    // create new node with label A[i]
    label[i] &larr; A[i]
    right[i] &larr; 0
    while label[last] > A[i] and last &ne; root
        last &larr; parent[last]
    if label[last] > A[i]    // A[i] is the smallest element yet; make it new root
        parent[root] &larr; i
        left[i] &larr; root
        root &larr; i
    if right[last] = 0       // just insert it
        right[last] &larr; i
        parent[i] &larr; last
        left[i] &larr; 0
    else                     // reconfigure links
        parent[right[last]] &larr; i
        left[i] &larr; right[last]
        right[last] &larr; i
        parent[i] &larr; last
</pre>

====Proof of correctness====
We define our invariant is as follows: ''After the loop in the above algorithm has run <math>m</math> times, we will have a valid Cartesian tree for the first <math>m+1</math> elements of <code>A</code>''.

This is true just before the loop runs for the first time (<math>m = 0</math>), because we will have a singleton tree that contains just the first element of <math>A</math>, and clearly this is a valid Cartesian tree for just that first element.

Now assume the loop has completed <math>m</math> iterations, but has not yet begun iteration <math>m+1</math>. Then, we have a valid Cartesian tree of the first <math>m+1</math> elements of <math>A</math>, and we wish to insert <math>A_{m+2}</math>. We first observe the following:
* The last node inserted, which we will call <math>v</math>, has no right child. This is because <math>v</math> must come last in the inorder traversal of the tree so far, as that tree is a valid Cartesian tree of all the elements added so far; but if <math>v</math> has a right child, then <math>\mathrm{right}[v]</math> will follow <math>v</math> in the inorder traversal.
* <math>v</math> is the right child of <math>\mathrm{parent}[v]</math>, if the latter exists. <math>\mathrm{parent}[v]</math> is furthermore the right child of <math>\mathrm{parent}[\mathrm{parent}[v]]</math>, and so on all the way up to the root. If this were not the case, then <math>v</math> would lie in the left subtree of some node <math>u</math>, and therefore <math>u</math> would follow <math>v</math> in the inorder traversal, a contradiction.
Then consider the three cases covered in the code:
# If <math>A_{m+2}</math> is less than the label of the tree's root, then after we make it the new root (with the old root as its left child), <math>A_{m+2}</math> will occur at the very end of the inorder traversal, since everything in the left subtree will be visited before it; but the order in which the previously inserted elements are visited will be unchanged. Also, since <math>A_{m+2}</math> is the smallest element in the tree, and it goes at the root, the tree maintains its min-heap-ordering property. Hence the invariant is preserved.
# If <math>A_{m+2} \geq A_{m+1}</math>, then after we have inserted a new node as the right child of <math>v</math>, this node will follow <math>v</math> in the inorder traversal, but the order in which all other elements are visited will be unchanged, so the effect is to append the new node to the end of the inorder traversal of the old tree. The new tree will also maintain its min=heap-ordering, since the new node inserted is greater than or equal to its parent. Therefore, the invariant is preserved.
# If we find some proper ancestor <math>u</math> of the most recently inserted node, whose label is less than or equal to <math>A_{m+2}</math>, but whose right child's label is greater than <math>A_{m+2}</math>, then <math>u</math> is visited immediately before all the elements in its right subtree, and those elements occur at the very end of the inorder traversal (since <math>u</math> is descended from the root of the tree along only right edges); furthermore all the elements in <math>u</math>'s right subtree are greater than or equal to the label of <math>\mathrm{right}[u]</math>. Now then, when we insert a new node as <math>u</math>'s right child, and make the original right child of <math>u</math> the left child of the new root, we see that all the elements formerly in <math>u</math>'s right subtree remain in <math>u</math>'s right subtree, that they are visited after <math>u</math> in the inorder traversal and all consecutively, and that the new node is visited at the very end; we conclude that the inorder traversal of the new tree is just the inorder traversal of the old tree with the new node visited at the very end. Also, since <math>A_{m+2}</math> is greater than or equal to <math>u</math>'s label, the min-heap-ordering is preserved at <math>u</math>; and since it is less than the label of <math>u</math>'s original right child, the min-heap-ordering is preserved here as well; so finally we conclude that the invariant is preserved. <math>_{\blacksquare}</math>

====Analysis of running time====
Observe that the loop in the algorithm given above performs at most a constant number of operations per iteration, plus some variable number of operations possibly spent ascending the tree looking for a place to insert the new element. Now define the ''active point'' of the tree to be the node pointed to by the <code>last</code> variable. Every time we ascend the tree by one node, we decrease the active point's depth by one. Then, either Case 1, Case 2, or Case 3 happens. In Case 1, the active point's depth is left unchanged, as it goes from being the old tree's root to being the new tree's root. In Cases 2 and 3, the active point's depth increases by one, since the new node inserted is one level deeper than its parent (the previous active point), and this new node becomes the new active point. So in total the depth of the active node cannot increase more than <math>N-1</math> times, once for each iteration of the loop. This means that it cannot decrease more than <math>N-1</math> times in total, either, because it starts at 0 and must finish as a non-negative integer. Hence the total number of times we ascend the tree is <math>O(N)</math> across all iterations of the loop, and all the other loop operations take <math>O(N)</math> time total, so the construction is completed in <math>O(N)</math> time. (This analysis also shows that each of the iterations of the loop uses amortized constant time.)

===Using all nearest smaller values===
Another construction method relies on finding [[all nearest smaller values]] of the sequence, which can be done in linear time. That is, for each element <math>A_i</math> in the sequence, we find the maximum <math>j < i</math> such that <math>A_j \leq A_i</math>; this is the ''nearest smaller value on the left'' (LNSV) . We also find the minimum <math>k > i</math> such that <math>A_k < A_i</math>, and call this the ''nearest smaller value on the right'' (RNSV).

''Theorem'': Consider the unique Cartesian tree of <math>A</math> obtained by considering the first of equal elements to be the smallest. (In such a tree, if node with label <math>x</math> has a left child with label <math>l</math>, then <math>l < x</math>, and if it has a right child with label <math>r</math>, then <math>r \leq x</math>.) Then, given an element <math>A_i</math> of the sequence, excepting that it is the root of the tree, it will be either the LNSV's right child or the RNSV's left child, as determined by the following rules:
# If the LNSV and RNSV both exist, the larger of the two is the parent of <math>A_i</math> in the tree. In case of a tie, the RNSV wins.
# If only the LSNV exists, it is <math>A_i</math>'s parent. If only the RNSV exists, it is <math>A_i</math>'s parent.
# If neither the LNSV nor the RNSV exists, <math>A_i</math> is the root.

''Proof'': Suppose that node labelled <math>A_i</math> is the right child of its parent. Then its parent must be labelled <math>A_j</math> where <math>j < i</math>, because <math>A_i</math> occurs ''after'' <math>A_j</math> in the inorder traversal. Also, <math>A_i \geq A_j</math>. Now suppose there exists <math>k</math> such that <math>j < k < i</math> and <math>A_i \geq A_k</math> (that is, <math>A_j</math> is not the LNSV to <math>A_i</math>). Then, <math>A_k</math> must occur ''after'' <math>A_j</math> in the inorder traversal, but ''before'' <math>A_i</math>. This is only possible if <math>A_k</math> occurs in the left subtree of the node labelled <math>A_i</math>. However, this implies that <math>A_k > A_i</math>, a contradiction. A similar analysis shows that if <math>A_i</math>'s parent occurs after <math>A_i</math> in the sequence <math>A</math>, it must be the RNSV of <math>A_i</math>. Now, pursuant to the three cases in the statement of the Theorem:
# Since the LNSV and RNSV exist, node labelled <math>A_i</math> is not the root. Therefore this node has a parent. The foregoing analysis shows that if node labelled <math>A_i</math> is the right child of its parent, then the parent is labelled with the LSNV, and if it is the left child, the parent is labelled with the RNSV. Suppose the former is true and <math>A_i</math>'s parent is its LNSV. Then the RNSV follows <math>A_i</math> and <math>A_j</math> in the inorder traversal. However, it cannot be in the right subtree of node labelled <math>A_i</math>, since its value is strictly less than <math>A_i</math>. It follows that it cannot be anywhere in the right subtree of <math>A_j</math> either (or anywhere in the subtree rooted at <math>A_j</math>). Now let <math>u</math> be the lowest common ancestor of the nodes labelled with <math>A_j</math> and the RNSV. If <math>u</math> ''is'' the node labelled with the RNSV, then node labelled <math>A_j</math> is in the RNSV's left subtree, which means <math>A_j</math> (the LNSV) is strictly greater than the RNSV, as desired. If not, then since the RNSV occurs after <math>A_j</math> in the inorder traversal, it must be that the RNSV is in <math>u</math>'s right subtree and node labelled <math>A_i</math> is in <math>u</math>'s left subtree. But then <math>u</math> occurs after <math>A_i</math> in the inorder traversal and before the RNSV, and <math>u</math>'s label is strictly less than <math>A_i</math>, which contradicts the "nearestness" of the supposed RNSV (so this case can never occur at all). A similar analysis shows that if node labelled <math>A_i</math> is the left child of its parent, then the parent is labelled with the RNSV and the RNSV is greater than or equal to the LNSV, as desired.
# If only the LSNV exists, then node labelled <math>A_i</math> still cannot be the root, but all the elements following <math>A_i</math> are greater than or equal to it, so node labelled <math>A_i</math> cannot be the left child of any node. Therefore it is the right child of its parent, and therefore its parent is the LNSV. Likewise, if only the RNSV exists, we see that node labelled <math>A_i</math> is the left child of its parent, and thus the parent must be the RNSV.
# If neither the LSNV nor the RNSV exists, then <math>A_i</math> is the leftmost occurrence of the minimum element in the sequence, and hence must be at the root of the tree. <math>_{\blacksquare}</math>

Using the preceding Theorem, after computing all nearest smaller values on both sides of each element (which requires linear time), we can determine each node's parent in constant time, so we obtain overall linear time construction.

==Applications==
* A [[range minimum query]] on a sequence is equivalent to a [[lowest common ancestor]] query on the sequence's Cartesian tree. Hence, RMQ may be reduced to LCA using the sequence's Cartesian tree.
* The [[treap]], a [[balanced binary search tree]] structure, is a Cartesian tree of (key,priority) pairs; it is heap-ordered according to the priority values, and an inorder traversal gives the keys in sorted order.
* The suffix tree of a string may be constructed from the [[suffix array]] and the [[longest common prefix array]]. The first step is to compute the Cartesian tree of the longest common prefix array. Details in the [[Suffix tree]] article.

[[Category:Trees]]
[[Category:Data structures]]