Ridiculous Operations in log(n) with Treaps
Ankit Sultana
June 4, 2021
Background
Heaps
insert(elem)
max() / min()
extract_max() / extract_min()
Binary Search Trees
search(elem)
delete(elem)
insert(elem)
max()
min()
lower_bound()
upper_bound()
BSTs
search(elem)
insert(elem)
remove(elem)
max()
min()
lower_bound(value)
upper_bound(value)
Binary Search Trees
search(elem)
delete(elem)
insert(elem)
max()
min()
lower_bound()
upper_bound()
BSTs
insert(elem)
search(elem)
remove(elem)
max()
min()
lower_bound()
upper_bound()
kth_smallest(k)
count_less_than(value)
Treaps
- Cartesian Tree: A tree with two keys in every node, such that the tree forms a BST on one key and a Heap on the other.
- Treap: A cartesian tree where the heap keys are random
Treap
This is a valid Treap, with two keys per node. The orange set of keys forms a BST and the green set forms a Min-Heap
Treap
Same Treap which tracks number of nodes in the sub-tree in each node
Treap
search(elem)
insert(elem)
delete(elem)
min()
max()
lower_bound(value)
upper_bound(value)
kth_smallest(k) /kth_largest(k)
count_less_than(value)
What Else Can I Do With Treaps?
Treaps can be used to represent "dynamic arrays":
Get Element at Index
Delete Element at Index
Insert Element at Index
Range Min/Max/Sum
Reverse Sub-Array
Transplant Sub-Array
Split Array / Merge Two Arrays
etc.
Main Treap Operations
Merge(Treap_1, Treap_2): This takes in two treaps, such that all BST values in Treap_1 are less than all BST values in Treap_2, and combines them.
Split(Treap, v): Creates two treaps from the input Treap, such that all values in one treap are <= v, and all the values in the other are > v
Merge Treap
Merge Treap
Merge Treap
Merge Treap
Merge Treap
Merge Treap
Implicit Treap
Treaps where the BST value is not explicitly stored
Allows the dynamic array operations discussed before
Relies on the fact there's a unique labelling for a BST with N nodes for labels in [1, N]
An array with N elements has unique indices
Implicit Treap
Relies on the fact there's a unique labelling for a BST with N nodes for labels in [1, N]
Implicit Treap
Relies on the fact there's a unique labelling for a BST with N nodes for labels in [1, N]
4
2
1
3
5
Implicit Treap
4
3
2
5
1
1
2
3
4
5
Treap T = new Treap(A[1]);
for (int i = 2; i <= 5; i++) {
T = Merge(T, new Treap(A[i]))
}Implicit Treap
4
3
2
5
1
1
2
3
4
5
4
1
103
3
1
49
Implicit Treap
4
3
2
5
1
1
2
3
4
5
4
1
103
3
2
49
2
1
70
Implicit Treap
4
3
2
5
1
1
2
3
4
5
4
1
103
3
3
49
2
1
70
5
1
11
Implicit Treap
4
3
2
5
1
1
2
3
4
5
4
1
103
3
3
49
2
1
70
5
4
11
1
1
84
Implicit Treap
4
3
2
5
1
1
2
3
4
5
4
1
103
3
3
49
2
1
70
5
5
11
1
1
84
Implicit Treap
4
3
2
5
1
4
1
103
3
3
49
2
1
70
5
2
11
1
1
84
1
2
3
1
2
Implicit Treap
4
3
2
5
1
4
1
103
3
2
49
2
1
70
5
2
11
1
1
84
1
1
2
1
2
Implicit Treap
4
3
2
5
1
4
1
103
3
2
49
2
1
70
5
2
11
1
1
84
1
1
2
1
2
Implicit Treap
4
3
2
5
1
4
1
103
3
5
49
2
1
70
5
3
11
1
1
84
1
2
3
4
5
Implicit Treap
4
3
2
5
1
4
1
103
3
5
49
2
1
70
5
3
11
1
1
84
1
2
3
4
5
R
Implicit Treap
4
3
2
5
1
4
1
103
3
5
49
2
1
70
5
3
11
1
1
84
1
2
3
4
5
R
R
Implicit Treap
4
3
2
5
1
4
1
103
3
5
49
2
1
70
5
3
11
1
1
84
1
2
3
4
5
R
R
R
Implicit Treap
Allow us to represent an array, with modification operations like:
insert/delete an element at any index
append an array to another
split an array into two
reverse a subarray
transplant a subarray
...
Implicit Treap
Allow us to represent an array, with read operations like:
get element at index
get sum/min/max of values for indices in [l, r]
get k-th smallest value in [l, r]
...
Persistent Implicit Treaps
All operations of Implicit Treaps with
*full immutability*
After each modification operation, a version is created, and each version is always accessible
Persistent Implicit Treaps - Merge
...
...
...
...
...
Persistent Implicit Treaps
All operations of Implicit Treaps with
*full immutability*
After each modification operation, a version is created, and each version is always accessible
Persistent Implicit Treaps
After each modification operation, a version is created, and each version is always accessible
When arrays A and B are merged to yield C, you can still perform any of the read-operations on all of A, B and C.
Other Data Structures
Splay Trees
Segment Trees (aka Interval Trees)
Binary Indexed Trees (aka Fenwick Trees)
Sparse Table
Fibonacci Heaps
...