Notes for week 8, Treaps

Treap is a data structure implementing the SSet interface. find(x), add(x), remove(x), first(), last(), prev(), next().

Reminders:

1. BSTs (binary search trees) support this interface, but the cost per operation is O(n) in the worst case, O(log(n)) only in the average case.
2. 'find' has two forms, findEQ(x) and find(x).
   1. findEQ(x) is the same as in USet (hash tables). It returns the item 'null' if no item equal to x is found.
   2. find(x) is the SSet operation that returns the smallest item y such that x ≤ y.
      1. y = x, if there is an equal item in the data,
      2. y is the next larger item than x in the data, if no item is equal to x, but
      3. y is 'null' if x is the largest item in the data.

The name is Treap derived from TREe-heAP. It is simultaneously a binary search tree and a heap,
  a random BST of user items (SSet interface) and
  a heap (Priority Queue interface) of random values.

Note that tree structure is random binary tree, not left complete tree, so while it has the heap property with regard to the random values, it is NOT an array-stored left complete binary tree (as in the binary heap implementation of priority queue).

class Node {
    T item;  // ODS text calls this x.
    int p; // priority
    Node* parent;
    Node* left;
    Node* right;
    // ... cstors
}

Properties of Treaps

• A treap is a binary search tree with respect to the user items and it is a heap with respect to the randomly assigned priorities.
• Therefore, the structure of the tree is the same as it would be if the items had been inserted in order as indicated by the priority.
• But the priority is randomly assigned. Therefore the tree is a random binary search tree.
• A random BST has expected height of O(log(n)) (more precisely about 2*ln(n)).
• Thus the expected cost of each of the BST operations (find(x), add(x), remove(x), first(), last(), prev(x), next(x) is O(log(n))

bool add(T x) {
  if x is in the treap, return false,
  otherwise 
    1. make Node* u = new Node(x, rand())
    2. insert u in the treap so as to 
       a) preserve the heap property with respect to priority, and 
       b) the binary search tree property with respect to x.
}

    2. a) add u in the BST way (preserves BST property)
       b) bubble up to restore heap property 
          (but it's not your classic bubbling)

Treap<char> S;
Step 1. S.add(k);  // add Node (k,7) [where 7 is random int]

    (k,7)

Step 2. S.add(c);  // add Node (c,15) [where 15 is random int]

    (k,7)
     /
  (c,15)

Step 3. S.add(h);  // add Node (h,9) 

Heap bubble step:  
    (k,7)   →     (k,7)
     /             /       
  (c,15)        (h,9)     
     \              \    
    (h,9)         (c,15)
XXXXXX try again...


    (k,7)   →     (k,7)
     /             /
  (c,15)        (h,9 )
     \            / 
    (h,9)     (c,15)

We've just done a rotation (rotate left).

Step 4. S.add(t);  // add Node (t,8) 

    (k,7)   →      (k,7)
     /              / \
  (h,9)         (h,9)  (t,8)
   /              /
 (c,15)       (c,15)

Step 5. S.add(d);  // add Node (d,2) 

    (k,7)     →     (k,7)    →     (k,7)      →      (d,2)
     /  \            / \            / \               / \
  (h,9) (t,8)   (h,9 )  (t,8)    (d,2) (t,8)      (c,15) (k,7)
    /             /               / \                     / \
 (c,15)       (d,2)           (c,15) (h,9)            (h,9) (t,8) 
    \          /
   (d,2)     (c,15)

(d,2), (k,7), (t,8), (h,9), (c, 15)

(d,2) → (d,2) → (d,2)   →   (d,2)     →    (d,2)
          \        \           \            / \
          (k,7)   (k,7)       (k,7)    (c,15)  (k,7)
                      \        /  \             /  \
                     (t,8)  (h,9) (t,8)      (h,9) (t,8)
                                    

T remove(T x) {
  if a y equal to x is not in the treap, return null,
  otherwise 
    1. find the node containing item equal to x.
    2. trickle u down until it is a leaf.
       a) fix the heap property with respect to priority, and 
       b) maintain the binary search tree property with respect to x.
    3  snip it off.
}

    2. trickle down:   
        if u is a leaf return
        if u has no left child or right child priority is less than left child's, 
             rotate left and trickle on down to the left.
        if u has no right child or left child priority is less than right child's, 
             rotate right and trickle on down to the right.

S.remove(k);  

    (d,2)     →     (d,2)    →     (d,2)      →      (d,2)
     /  \            /  \            / \               / \
  (c,15) (k,7)   (c,15) (t,8)    (c,15) (t,8)      (c,15) (t,8)
          / \           /                /                 / 
      (h,9) (t,8)    (k,7)            (h,9)             (h,9)
                     /                   \
                  (h,9)                 (k,7)

clicker questions.