Treap

#include<iostream>
#include<algorithm>
using namespace std;
#define MAX_NODE_NUM 10000
struct TreapNode{
    int key;
    int priority;
    int size;    //以该节点为根的子树中含有的元素（相同key重复计算）的数目

    int count;  //该节点中元素的个数（各个节点的元素必定不同，但一个节点可以含有多个相同的元素）。
                //count就指示这棵树中含有多少个key

    TreapNode* child[2];
    TreapNode(int val = 0){
        key = val;
        child[0] = 0;
        child[1] = 0;
        size = 1;
        count = 1;
        priority = rand();
    }
    void Update(){
        size = count;
        if (child[0]){
            size += child[0]->size;
        }
        if (child[1]){
            size += child[1]->size;
        }
    }
};
struct Treap{
    TreapNode* root;
    Treap() :root(NULL){};

    //注意这里，node 为引用，这样，不需要知道node的父节点，在将 node赋值为 child时候，
    //自动实现了node的父节点和node的子节点的链接
    void Rotate(TreapNode*& node, int dir){
        TreapNode* child = node->child[dir];
        node->child[dir] = child->child[!dir];
        child->child[!dir] = node;
        node->Update(); //这时候node已经旋转到下方一层，因此size可能发生变化
        node = child;
    }

    //向treap中插入元素
    //注意这里的node为指针的引用！！ 这样在新建节点的时候，可以避免回去赋值
    void Insert(TreapNode*& node, int x){
        if (!node){
            node = new TreapNode(x);
        }
        else if (node->key == x){
            node->count++;
        }
        else{
            int dir = node->key < x;
            Insert(node->child[dir], x);
            if (node->child[dir]->key > node->key){
                Rotate(node, dir);
            }
        }
        node->Update();
    }

    //注意这里的node为指针的引用！！ 因为其中涉及到了Rotate操作需要使用指针的引用
    void Delete(TreapNode*& node, int key){
        if (node->key == key){
            if (node->child[0] && node->child[1]){
                int dir = node->child[0]->priority < node->child[1]->priority;
                Rotate(node, dir);    
                //Rotate中的node为引用，Rotate返回的时候，node指向的是其 原来的child[dir]（此时为node的父节点）
                //此时node向下移动了一层，继续递归调用 Delete，直到node的某个叶子节点为空
                Delete(node->child[!dir], key);
            }
            else{
                TreapNode* tmp_node = NULL;
                if (node->child[0])
                    tmp_node = node->child[0];
                else if (node->child[1])
                    tmp_node = node->child[1];
                delete node;    //释放指针
                node = tmp_node; //对指针的引用进行赋值
            }
        }
        else{
            int dir = node->key < key;
            Delete(node->child[dir], key);
        }
        node->Update(); //因为涉及到更改节点，故update size 可能发生改变

    }

    //返回tree中第k个节点
    TreapNode* FindKth(TreapNode* tree, int k){
        TreapNode* node = tree;
        while (node){
            if (! node->child[0]){
                if (k == 1){
                    return node;
                }
                else{
                    k--;
                    node = node->child[1];
                    continue;
                }
            }
            else{
                if (node->child[0]->size + 1 == k){
                    return node;
                }
                else if (node->child[0]->size >= k){
                    node = node->child[0];
                }
                else{
                    k -= (node->child[0]->size + 1);
                    node = node->child[1];
                }
            }
        }
        return NULL; 
    }

    //返回以node为根的子树中，节点的key值小于等于k的节点的个数
    int GetLessK(TreapNode* node, int k){
        int sum = 0;
        if (!node){
            return 0;
        }
        if (node->key > k){
            sum += GetLessK(node->child[0], k);
        }
        if (node->key <= k){
            sum += node->count;  // count

            if (node->child[0]){
                sum += node->child[0]->size;
            }
            sum += GetLessK(node->child[1], k);
        }
        return sum;
    }
};