Astfel, din moment ce $T$ este un heap, nodul $v$ cu prioritatea cea mai mare trebuie să fie rădăcina. Cum este şi un arbore binar de căutare, orice nod $u$ cu $cheie(u) < cheie(v)$ se găseşte în subarborele stâng al lui $v$, şi orice nod $w$ cu $cheie(w) > cheie(v)$ se găseşte în subarborele drept.
h2. Operaţii

 
== code(cpp) |
#include <cstdio>
#include <algorithm>
 
using namespace std;
 
const char iname[] = "c:\\input.txt";
const char oname[] = "c:\\output.txt";
 
struct T {
    int key;
    int priority;
    T *left, *right;
} *R, *nil;     // R radacina; nil arata un nod `gol`
 
void init(void)
{
    srand(17);
    R = nil = new T();
    nil->key = nil->priority = 0,
        nil->left = nil->right = NULL;
}
 
T* rotleft(T *n)    // roteste fiul stang
{
    T *t = n->left;
    n->left = t->right, t->right = n;
    return t;       // noua radacina
}
 
T* rotright(T *n)   // roteste fiul drept
{
    T *t = n->right;
    n->right = t->left, t->left = n;
    return t;       // noua radacina
}
 
T* balance(T *n)    // restabileste invariantul heapurilor
{
    // balance() e apelat dupa un insert(), deci doar cel mult unul
    // din fii nu respecta invariantul heapurilor
    if (n->left->priority > n->priority)
        return rotleft(n);
 
    if (n->right->priority > n->priority)
        return rotright(n);
 
    return n;       // altfel nu face nimic
}
 
T* insert(T *n, int key)
{
    if (n == nil)   // am gasit locul in care trebuie inserat cheia key
    {
        n = new T();
        n->key = key, n->priority = rand() + 1,
                    n->left = n->right = nil;
        return n;
    }
    if (key < n->key)
        n->left = insert(n->left, key);
    else if (key > n->key)
        n->right = insert(n->right, key);
    return balance(n);      // restabileste invariantul heapurilor
}
 
T* erase(T *n, int key)
{
    if (n != nil)
    {
        if (key < n->key)
            n->left = erase(n->left, key);
        else if (key > n->key)
            n->right = erase(n->right, key);
        else {
            // am gasit cheia
            // pune fiul cu prioritatea cea mai mare ca radacina in locul lui `n`
            n = (n->left->priority > n->right->priority) ? rotleft(n) : rotright(n);
            if (n != nil)   // continua
                n = erase(n, key);
            else {
                delete n->left;
                n->left = NULL;
            }
        }
    }
    return n;
}
 
T* empty(T *n)
{
    if (n != nil)
    {
        empty(n->left);
        empty(n->right);
        delete n;
    }
    return nil;
}
 
void print(T *n)
{
    if (n != nil)
    {
        print(n->left);
        printf("%d ", n->key);
        print(n->right);
    }
}
 
int main(void)
{
    init();
    // 1 s pentru a insera un milion de numere
    for (int i = 1 << 20; i >= 1; -- i)
        R = insert(R, i);
    // 0.5 s pentur a sterge un milion de numere
//    for (int i = 1; i <= 1 << 20; ++ i)
//        R = erase(R, i);
 
    R = empty(R);
    return 0;
}
==