非旋转Treap

#include<iostream>
#include<algorithm>
using namespace std;
#define MAX_NUM 100
struct TreapNode{
	int key;
	int priority;
	int size;
	TreapNode* left;
	TreapNode* right;
	TreapNode(int k){
		key = k;
		size = 1;
		priority = rand();
		left = right = NULL;
	}
	void Update(){
		size = 1;
		if (left)
			size += left->size;
		if (right)
			size += right->size;
	}
};

int GetSize(TreapNode* node){
	if (node)
		return node->size;
	return 0;
}
void Build(int *arr, int n){
	sort(arr, arr + n); //先进行排序
	TreapNode* stack[MAX_NUM];
	TreapNode* last;
	int p = 0;
	TreapNode* new_node;
	for (int i = 0; i < n; i++){
		last = NULL;
		new_node = new TreapNode(arr[i]);
		//直到栈为空，或者栈顶元素priority小于当前节点的priority
		while (p && stack[p]->priority > new_node->priority){
			last = stack[p--];
		}
		stack[p]->right = new_node;	//新节点作为p的右子节点
		new_node->left = last;		//前一次出栈的节点作为 新节点的左子结点
		stack[++p] = new_node; //新插入元素入栈
	}
}

TreapNode* Merge(TreapNode* treap1, TreapNode* treap2){
	if (!treap1)
		return treap2;
	if (!treap2)
		return treap1;

	if (treap1->priority < treap2->priority){
		treap1->right = Merge(treap1->right, treap2);
		treap1->Update();
		return treap1;
	}
	else{
		treap2->left = Merge(treap1, treap2->left);
		treap2->Update();
		return treap2;
	}
}

typedef pair<TreapNode*, TreapNode*> TreapPair;
TreapPair Split(TreapNode* treap, int k){
	if (!treap){
		return TreapPair(NULL, NULL);
	}
	TreapPair result;
	if (treap->left->size >= k){
		result = Split(treap->left, k);
		treap->left = result.second;
		treap->Update();
		result.second = treap;
	}
	else{
		result = Split(treap->right, k - treap->left->size - 1);
		treap->right = result.first;
		treap->Update();
		result.first = treap;
	}
	return result;
}

//注意为treapNode指针引用
int FindKth(TreapNode*& treap, int k){
	TreapPair x = Split(treap, k - 1);
	TreapPair y = Split(x.second, 1);
	int result = y.first->key;
	treap = Merge(x.first, y.first);
	treap = Merge(treap, y.second);
}

//询问一个数是第几大
int GetKth(TreapNode* treap, int v){
	if (!treap)
		return 0;
	if (v < treap->key)
		return GetKth(treap->left, v);
	else
		return GetKth(treap->right, v) + GetSize(treap->left) + 1;
}

void Insert(TreapNode*& treap, int v){
	int k = GetKth(treap, v);
	TreapPair result = Split(treap, k);
	TreapNode* new_treap = new TreapNode(v);
	treap = Merge(result.first, new_treap);
	treap = Merge(treap, result.second);
}

void Delete(TreapNode*& treap, int k){
	TreapPair x = Split(treap, k - 1);
	TreapPair y = Split(x.second, 1);
	treap = Merge(x.first, y.second);
}