Treap

 Treap是一种弱平衡二叉查找树，通过给每个节点赋优先值以及必要时进行节点的旋转来避免一般的二叉查找树退化成一条链，从而具有良好的时间性能。 
    Treap实现将二叉查找树的高度值期望达到O(logn)，这条性质由定理

将一组数据以随机的顺序插入一棵二叉查找树中，树的高度期望为 O(logn)

得以保证。

Treap性质

    Treap是一棵二叉查找树，同时是一个堆。Treap的每个节点至少有两个属性: key 和 priority. 其中key是节点保存的数据，在中序遍历treap的时候，得到的序列为原始给定序列；priority为节点的权重，在生成节点的时候由随机的方式给出即可，priority满足最大（或最小堆）的性质，即treap中父节点的priority大于子节点的priority。

1.父节点的key大于左子树所有节点的key，小于右子树所有节点的key。 
2. 中序遍历得到的key序列为原始序列 
3. 父节点的priority大于子节点的priority

Treap维护

    Treap需要满足以上给出的性质，这通过节点的旋转来实现。treap中的节点旋转只有单旋转，zig或者zag（这在旋转中介绍的比较详细，此处略过）。即如果在节点的操作（比如插入、删除等）中出现了违反最大堆性质的情况（父节点的priority不大于子节点的priority），则进行节点的旋转，将父节点旋转到子节点下方。

Treap实现(c++)

#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]->priority > node->priority){
                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 <= node->count){
                    return node;
                }
                else{
                    k -= node->count;
                    node = node->child[1];
                    continue;
                }
            }
            else{
                if (node->child[0]->size + node->count >= k && node->child[0]->size < k){
                    return node;
                }
                else if (node->child[0]->size >= k){
                    node = node->child[0];
                }
                else{
                    k -= (node->child[0]->size + node->count);
                    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;
    }
};