指针实现 Treap

前置知识：二叉排序树，堆。

应用场景：平衡树。

---

〇、导入

1. 二叉排序树

我们都知道，二叉排序树就是满足“(lch<now<rch)”（左儿子小于根节点，右儿子大于根节点）的二叉树，一般情况下插入、删除和搜索的时间复杂度都为 (Theta(log n)) ，非常快。但在特殊情况下，二叉排序树可能会退化成链，时间复杂度也会变为 (Theta(n)) 。只有当二叉排序树平衡时速度最优。

2. 堆

堆也很简单，就是根节点大于子节点的完全二叉树。

3. 平衡树

当二叉排序树退化成链时速度会大打折扣，因此很多毒瘤出题者都喜欢卡它。但是既然能有这种题目，那么肯定就有能解决的方法，当然也不排除出题者自己都没有做出来。二叉排序树平衡时时间复杂度为 (Theta(log n)) 。所以，若要保证二叉排序树的最大时间复杂度为 (Theta(log n)) ，就要保证该二叉排序树平衡。这就是是平衡树。

平衡树有很多种，本文就不再赘述，仅讨论 Treap。

4. Treap

二叉排序树和堆都是二叉树。既然堆就是完全二叉树，何不利用它这个性质来保证二叉排序树平衡呢？

于是 Tree(二叉排序树)+Heap(堆)=Treap ，Treap 横空出世！

一、操作&实现

1. 存储

这里我定义了一个结构体 Treap 来封装，然后再 Treap 内又定义了结构体 node ，表示节点。

struct Treap
{
	struct node
	{
		int val,size,times;
		unsigned rd;
		node *ch[2];
	}e[100005],*root,*cnt;
};

解读：

• Treap：表示 Treap。
  • node：表示节点。
    • val：表示该节点所储存的数值。
    • size：表示以该节点为根的子树的大小（节点总数）。
    • times：表示该节点的数值的存在数量。
    • rd：随机优先值。
    • ch：指向子节点的指针。
      • ch[0]：指向左儿子的指针。
      • ch[1]：指向右儿子的指针。
  • e：储存所有节点。
  • root：指向根节点的指针。
  • cnt：指向最后一个插入的节点的指针。

如果没能看懂各变量的作用也没有关系，在后面的操作中会为您一一解答。

2. 操作

2-0 node 的操作

2-0-1 构造函数

node(){}
// 插入节点时用
node(const int &x){val=x,size=times=1,rd=rand(),ch[0]=ch[1]=NULL;}

优化

C++ 自带的 rand 函数速度较慢，我们可以自己写一个 mrand 函数来取代：

inline unsigned mrand()
{
	static unsigned long long tr=431322;
	return unsigned(tr=(tr*76717)%0x100000000);
}

大家可能 static 用得较少，这里就不阐述原理了，感兴趣的可以自行百度。

然后构造函数如下：

node(){}
// 插入节点时用
node(const int &x){val=x,size=times=1,rd=mrand(),ch[0]=ch[1]=NULL;}

2-0-2 更新节点信息

不解释：

inline void pushup()
{
	size=times;
	if(ch[0])	size+=ch[0]->size;
	if(ch[1])	size+=ch[1]->size;
}

现在 node 实现如下：

struct node
{
	int val,size,times;
	unsigned rd;
	node *ch[2];
	node(){}
	node(const int &x){val=x,size=times=1,rd=mrand(),ch[0]=ch[1]=NULL;}
	inline void pushup()
	{
		size=times;
		if(ch[0])	size+=ch[0]->size;
		if(ch[1])	size+=ch[1]->size;
	}
};

下面实现操作的函数均为 Treap 的成员函数。

附：调试函数，输出当前树的详细信息：

// now 表示所操作子树的根节点指针引用，indent 表示当前缩进长度
void output(node *&now,const int &indent)
{
	putchar('>'),putchar(' ');
	for(int i=0;i<indent;++i)	putchar('|'),putchar(' ');
	if(!now)
	{
		puts("NULL");
		return;
	}
	// 输出当前节点的详细信息，可以更改
	printf("%ld:%d %d,%d %u
",now-e,now->val,now->size,now->times,now->rd);
	output(now->ch[0],indent+1);
	output(now->ch[1],indent+1);
}
// 初始函数（方便调用）
inline void output(){output(root,0);}

2-1 旋转

旋转是很多平衡树常见的操作，分为左旋和右旋。

左旋的操作如下：

右旋的操作与此类似，仅方向不同。事实上，右图中的树右旋后即可得到左图。

实现的代码也很简单：

// now 表示所操作子树的根节点指针引用，d 表示旋转方向（0 表示右旋，1 表示左旋）
// 这里 now 为引用类型，便于更改。
inline void rotate(node *&now,const bool &d)
{
	node *tmp=now->ch[d];			// tmp 指向将成为新的根节点的节点
	now->ch[d]=tmp->ch[!d];
	tmp->ch[!d]=now;
	tmp->pushup(),now->pushup();	// 更新节点信息
	now=tmp;						// tmp 指向的节点成为新的根节点
}

那么为什么要旋转呢？因为每个节点都会有一个随机优先值，而 Treap 的每个节点的优先值都比其子节点的大，利用堆的思想，使得 Treap 相对平衡。

2-2 插入值为 (x) 的节点

Treap 的插入其实就是在二叉排序树的插入的基础上通过旋转保证 Treap 堆的性质。

// now 表示指向当前节点的指针的引用，x 表示要插入的值
// 这里 now 为引用类型，便于更改。
void insert(node *&now,const int &x)
{
	// 如果为空指针
	if(!now)
	{
		*(now=++cnt)=x;		// 插入新节点
		return;
	}
	++(now->size);			// 因为新节点在以 now 指向的节点为根节点的子树内，所以当前子树的节点数+1
	// 如果当前节点的数值不等于 x
	if(now->val!=x)
	{
		bool d=now->val<x;	// d 为插入的方向（0 为左，1 为右）
		insert(now->ch[d],x);
		// 如果当前节点的子节点的优先值大于当前节点的优先值（即不符合堆的性质）
		if(now->ch[d]->rd>now->rd)	rotate(now,d);	// 旋转以维护堆的性质
	}
	// 否则说明当前节点的数值等于 x
	else	++(now->times);	// 当前节点的数值的存在数量+1
	now->pushup();			// 更新当前节点（之前我没有加上，导致我调了好久的 BUG）
}
// 初始函数（方便调用）
inline void insert(const int &x){insert(root,x);}

2-3 删除值为 (x) 的节点

首先找到要删除的节点，然后通过旋转将其下移，直到其没有子节点时之间再将其直接删除。

// now 表示指向当前节点的指针的引用，x 表示要删除的值
// 这里 now 为引用类型，便于更改。
void remove(node *&now,const int &x)
{
	// 如果当前节点不为要删除的节点
	if(now->val!=x)	remove(now->ch[now->val<x],x);	// 继续向下寻找
	// 否则说明要删除当前节点
	// 如果当前节点有左儿子并且左儿子的优先值大于右儿子的优先值
	// 则右旋使左儿子代替被删除的节点的位置
	else if(now->ch[0] && (!now->ch[1] || now->ch[0]->rd>now->ch[1]->rd))	rotate(now,0),remove(now->ch[1],x);
	// 否则如果当前节点有右儿子
	// 则左旋使右儿子代替被删除的节点的位置
	else if(now->ch[1])	rotate(now,1),remove(now->ch[0],x);
	// 否则说明当前节点没有子节点
	else
	{
		--(now->size);
		// 如果该节点的存在数量清零了
		if(!--(now->times))	now=NULL;	// 直接删除
		return;
	}
	now->pushup();// 更新当前节点
}
// 初始函数（方便调用）
inline void remove(const int &x){remove(root,x);}

2-4 查询数值为 (x) 的节点的排名

这个与二叉排序树的操作一样。

// now 表示指向当前节点的指针的引用，x 表示要查询的值
int getrank(node *&now,const int &x)
{
	// 如果为空指针，说明改数不存在于树中
	if(!now)	return 0;							// 直接返回 0
	// 如果当前节点的值大于 x
	if(now->val>x)	return getrank(now->ch[0],x);	// 继续搜索左子树
	// 如果当前节点的值小于 x
	// 继续搜索右子树，返回值增加左子树节点数+当前节点存在数量
	if(now->val<x)	return getrank(now->ch[1],x)+(now->ch[0]?now->ch[0]->size:0)+now->times;
	// 否则说明当前节点的值等于 x
	return (now->ch[0]?now->ch[0]->size:0)+1;		// 返回左子树节点数+1
}
// 初始函数（方便调用）
inline int getrank(const int &x){return getrank(root,x);}

2-5 查询排名为 (x) 的节点的数值

// now 表示指向当前节点的指针的引用，x 表示要查询的排名
int getval(node *&now,const int x)
{
	static int tmp;	// 临时变量，用于储存左子树的节点数+当前节点存在数量，为了节省空间就使用静态变量了
	// 如果当前节点有左儿子且左子树的节点数不小于 x
	// 继续搜索左子树
	if(now->ch[0] && now->ch[0]->size>=x)	return getval(now->ch[0],x);
	// 否则如果当前节点有右儿子且左子树的节点数+当前节点存在数量小于 x
	// 继续搜索右子树中排名为 x-tmp 的节点
	if(now->ch[1] && ((tmp=(now->ch[0]?now->ch[0]->size:0)+now->times)<x))	return getval(now->ch[1],x-tmp);
	// 否则说明当前节点即要查询的节点
	return now->val;// 返回当前节点的数值
}
// 初始函数（方便调用）
inline int getval(const int &x){return getval(root,x);}

2-6 查询数值为 (x) 的节点的前驱

// now 表示指向当前节点的指针的引用，x 表示要查询的数值
int getprev(node *&now,const int &x)
{
	// 如果为空指针
	if(!now)	return -0x80000000;						// 返回负无穷
	// 如果当前节点的数值不小于 x
	// 说明前驱在左子树内
	if(now->val>=x)	return getprev(now->ch[0],x);		// 搜索左子树
	// 否则说明前驱为当前节点或在右子树内
	else	return max(now->val,getprev(now->ch[1],x));	// 搜索右子树
}
// 初始函数（方便调用）
inline int getprev(const int &x){return getprev(root,x);}

2-7 查询数值为 (x) 的节点的后继

与查询前驱思路相同。

// now 表示指向当前节点的指针的引用，x 表示要查询的数值
int getnext(node *&now,const int &x)
{
	// 如果为空指针
	if(!now)	return 0x7fffffff;						// 返回负无穷
	// 如果当前节点的数值不大于 x
	// 说明后继在左子树内
	if(now->val<=x)	return getnext(now->ch[1],x);		// 搜索左子树
	// 否则说明后继为当前节点或在右子树内
	else	return min(now->val,getnext(now->ch[0],x));	// 搜索右子树
}
// 初始函数（方便调用）
inline int getnext(const int &x){return getnext(root,x);}

二、例题

1. 洛谷 P3369 【模板】普通平衡树

题目链接：https://www.luogu.com.cn/problem/P3369 。

这是一道模板题，没什么好说的，直接上代码：