平衡树学习笔记

二叉搜索树

平衡树的基础。

二叉搜索树是一种二叉树，并且满足左儿子的值小于根的值，右儿子的值大于根的值。

并且二叉搜索树的子树也是二叉搜索树。

基础操作：

先来规定一下变量名：

\(siz[now]\) 表示以 \(now\) 为根的子树大小，\(ls[now]\) 表示 \(now\) 的左儿子，\(rs[now]\) 表示 \(now\) 的右儿子。

\(val[now]\) 表示 \(now\) 节点的权值，\(cnt[now]\) 表示 \(now\) 节点权值的数量。

遍历操作：

如果没有儿子了直接返回，然后遍历左右儿子输出。

void print(int now) {
	if(!now) return;
	print(lc[now]);
	for(int i = 1; i <= cnt[now]; i++)
		printf("%d ", val[now]);
	print(rc[now]);
}

查找最值操作：

因为左儿子是最小的，我们从根节点出发，一直找左儿子，最终找到的左儿子所代表的权值就是最小值。

因为右儿子是最小的，我们从根节点出发，一直找右儿子，最终找到的右儿子所代表的权值就是最大值。

int findMin(int now) {
	if(!lc[now]) return now;
	return findMin(ls[now]);
}

int findMax(int now) {
	if(!rc[now]) return now;
	return findMax(rs[now]);
}

插入操作：

考虑从根节点出发，找属于他的位置。

如果当前没有这个节点，说明需要新建节点。

如果有的话，就根据二叉搜索树的性质。

如果 \(v\) 比当前的值小，去左儿子找。

如果 \(v\) 跟当前的值相等了，个数加 \(1\)，然后返回。

如果 \(v\) 比当前的值大，去右儿子找。

void Insert(int &now, int v) {
	if(!now) {
		now = ++idx;
		val[now] = v, cnt[now] = siz[now] = 1;
		return;
	}
	siz[now]++;
	if(val[now] > v) Insert(ls[now], v);
	if(val[now] == v) return cnt[now]++, void();
	if(val[now] < v) Insert(rs[now], v);
}

删除操作：

如果是删除最值操作。

如果是删除最小值，就是一直遍历到最后，如果说是叶子节点，就直接删除。

如果不是叶子节点，因为是找最小值再删除，我们先一直遍历左儿子，到了没有左儿子的节点，将这个节点删除就是将这个节点直接变成自己的右儿子。

删除最大值同理。

int deletemin(int &now) {
	if(!ls[now]) {
		int u = now; now = rs[now];
		return u;
	}
	else {
		int u = deletemin(lc[now]);
		siz[now] -= cnt[u];
		return u;
	}
}

int deletemax(int &now) {
	if(!rs[now]) {
		int u = now; now = ls[now];
		return u;
	}
	else {
		int u = deletemax(rc[now]);
		siz[now] -= cnt[u];
		return u;
	}
}

如果是随便删除一个权值为 \(v\) 的点呢。

我们从根节点出发，根据二叉搜索树的性质，去找到 \(v\) 所在的位置。

如果这个地方 \(cnt[now] > 1\) 直接减 \(1\)，然后返回。

否则如果这个节点只有一个儿子，那么直接加这个节点设成他的儿子。

如果有两个儿子，就将这个节点变成左儿子的最大值或者右儿子的最小值。

void Del(int &now, int v) {
	siz[now]--;
	if(val[now] == v) {
		if(cnt[now] > 1) {
			cnt[now]--; return;
		}
		if(ls[now] && rs[now]) now = deletemin(rs[now]);
		else now = ls[now] + rs[now];
		return;
	}
	if(val[now] > v) Del(ls[now], v);
	if(val[now] < v) Del(rs[now], v);
}

求排名操作：

从根节点出发，根据权值不断的找即可。

求元素排名：

int Rank(int now, int v) {
	if(val[now] == v) return siz[ls[now]] + 1;
	if(val[now] > v) return Rank(ls[now], v);
	if(val[now] < v) return Rank(rs[now], v) + siz[ls[now]] + cnt[now];
}

求排名的元素：

int kth(int now, int k) {
	if(siz[ls[now]] >= k) return kth(ls[now], k);
	if(siz[ls[now]] < k - cnt[now]) return kth(rs[now], k - siz[ls[now]] - cnt[now]);
	return val[now];
}

Splay

全名伸展树。

是一种通过玄学旋转来实现树的平衡的树。

反正复杂度是对的。

基础操作：

旋转操作：

我们要让 \(x\) 当 \(y\) 的爹，但是又要满足二叉搜索树的性质。

现在 \(x\) 是 \(y\) 的左儿子，所以 \(val_x < val_y\)。

所以 \(x\) 想当爹的话 \(y\) 就要成为 \(x\) 的右儿子。

但是 \(x\) 的右儿子上已经有人了。

于是我们考虑 \(x, B, y\) 的关系： \(y > B > x\) 。

\(x\) 的爹就变成了 \(z\)。

所以我们直接把 \(y\) 的左儿子变成 \(B\)，这样就完成了旋转。

大概总结一下这个规律：

\(y\) 是 \(x\) 的爹， \(z\) 是 \(y\) 的爹。

如果说 \(x\) 是 \(y\) 的 \(id\) 号儿子。

如果说 \(id = 1\) 说明是右儿子， \(id = 0\) 就是左儿子。

如果 \(x\) 是左儿子，说明了 \(y\) 要当 \(x\) 的右儿子。

如果说 \(x\) 是右儿子，说明了 \(y\) 要当 \(x\) 的左儿子。

• 所以说 \(y\) 总是会当 \(x\) 的 \(id \wedge 1\) 号儿子。

然后 \(x\) 的 \(id ^ 1\) 号儿子因为 \(y\) 的到来，要变成 \(y\) 的 \(id\) 号儿子。

最后更新父节点的信息，更新旋转后节点的子树大小即可。

void moveroot(int x) {
	int y = tree[x].fa; 
	int z = tree[y].fa;
	int k = (tree[y].ch[1] == x); // x 是 y 的哪个儿子
	tree[z].ch[tree[z].ch[1] == y] = x; // 更新 z 的儿子是 x
	tree[x].fa = z; // x 的爹是 z
	tree[y].ch[k] = tree[x].ch[k ^ 1]; // x 的原来要变成 y 的那个儿子成为了 y 的儿子。
	tree[tree[x].ch[k ^ 1]].fa = y; // 更新爹
	tree[x].ch[k ^ 1] = y; // y 成为了 x 的子树
	tree[y].fa = x; // y 的爹是 x
}

如果你觉得这样就能使树平衡就大错特错了，还是有数据可以hack的。

依旧是上面那个图。

按照要求不断的旋转 \(x\) 节点。

然后继续旋转 \(x\) 节点。

然后你就发现，这不是寄了，旋转完之后还是一条链。

本身上是因为让 \(x\) 不断的旋转，结果 \(x, y, z\) 是一条链，然后不断的旋转只是把 \(y, z\) 移动他的同一个儿子罢了。

所以我们先转一下 \(y\) 节点，然后不断的去转 \(x\) 就行了。

先旋转 \(y\) 节点。

然后旋转 \(x\) 节点。

void splay(int x, int goal) {
	while(tree[x].fa != goal) { // 当他的爹不是目标节点的时候
		int y = tree[x].fa, z = tree[y].fa;
		if(z ^ goal) // 为啥防止转两遍然后把 x 直接转到目标
			(tree[z].ch[1] == y) ^ (tree[y].ch[1] == x) ? moveroot(x) : moveroot(y); // 判断是否是链
		moveroot(x);
	} 
	if(!goal) root = x; // 更新根节点
}

查找操作：

我们从根节点出发，如果树是空的直接返回。

否则去找那个儿子，根据权值的大小去找儿子。

最后为了后面的求前驱后继操作，把找到的这个节点转到根节点。

void find(int x) {
	int u = root;
	if(!u) return; // 如果是空树 
	while(tree[u].ch[x > tree[u].val] && x != tree[u].val) // 找符合条件的儿子跳过去
		u = tree[u].ch[x > tree[u].val];
	splay(u, 0); // 旋转到根节点，维护树的平衡
}

插入操作：

我们从根节点出发，找到他应该插入的位置。

如果这个位置存在，\(cnt\) 加 \(1\)，然后返回。

如果说不存在，新建一个节点。

void Insert(int x) {
	int u = root, fa = 0;
	while(u && tree[u].val != x)
		fa = u, u = tree[u].ch[x > tree[u].val];
	if(u) tree[u].cnt++;
	else {
		u = ++idx; 
		if(fa) tree[fa].ch[x > tree[fa].val] = u;
		tree[idx].fa = fa, tree[idx].val = x, tree[idx].cnt = 1, tree[idx].siz = 1;
	}
	splay(u, 0);
}

前驱后继操作：

先找到这个位置，但是不一定能直接找到，先查找这个位置，然后把他变成根，这样前驱就是左子树最大值。

后继就是右子树最小值。

int Next(int x, int f) {
	find(x);
	int u = root;
	if(tree[u].val > x && f) return u;
	if(tree[u].val < x && !f) return u;
	u = tree[u].ch[f];
	while(tree[u].ch[f ^ 1]) u = tree[u].ch[f ^ 1];
	return u;
}

删除操作：

首先找到这个数的前驱，把他Splay到根节点。
然后找到这个数后继，把他旋转到前驱的底下。
比前驱大的数是后继，在右子树。
比后继小的且比前驱大的有且仅有当前数。
在后继的左子树上面。
因此直接把当前根节点的右儿子的左儿子删掉就可以啦。

void Delete(int x) {
	int last = Next(x, 0);
	int nxt = Next(x, 1);
	splay(last, 0), splay(nxt, last);
	int del = tree[nxt].ch[0];
	if(tree[del].cnt > 1) {
	    tree[del].cnt--, splay(del, 0);
	}
	else tree[nxt].ch[0] = 0;
}

FHQ-Treap

码量短的平衡树，几分钟就能写完，并且特别好调，推荐学习这种。

split 操作：

分裂操作，按值 \(v\) 分裂，分裂成两颗子树 \(x\) 和 \(y\)，\(x\) 上的值都 \(\le v\)，\(y\) 上的值都 \(> v\)。

从根节点开始，如果当前节点的权值 \(\le v\)，说明他的左子树也 \(\le v\)，但是右子树可能有一部分 \(\le v\)，所以去递归处理右子树，同时为了找到分裂后真正的 \(p\) 的右儿子。

值 \(> v\) 的时候一样。

inline void split(int p, int v, int &x, int &y) {
	if(!p) {x = y = 0; return;}
	if(tr[p].val <= v) x = p, split(rs(x), v, rs(x), y);
	else y = p, split(ls(y), v, x, ls(y)); 
	pushup(p);
}

merge 操作：

分裂操作的逆操作，将两颗子树按照随机的 \(key\) 值合并起来，如果 \(key(x) \le key(y)\)，按照小根堆， \(x\) 需要在 \(y\) 的上面，因为 \(x\) 的权值小于 \(y\) 的权值，所以只需要把 \(rs(x)\) 与 \(y\) 合并起来当做 \(x\) 的右儿子就行了。

inline int merge(int x, int y) {
	if(!x || !y) return x + y;
	if(tr[x].key < tr[y].key) {	rs(x) = merge(rs(x), y); pushup(x); return x;}
	else {ls(y) = merge(x, ls(y)), pushup(y); return y; }
}

insert 操作：

插入一个权值为 \(v\) 的点，先按权值 \(v\) 分裂成 \(x, y\)，然后新建一个权值为 \(v\) 的节点，把 \(x, z\) 合并起来，再和 \(y\) 合并。

inline void Insert(int v) {
	split(root, v, x, y);
        z = newnode(v); 
        root = merge(merge(x, z), y);
}

delete 操作：

删除一个权值为 \(v\) 的点，先按权值 \(v\) 分裂成 \(x, z\)，再把 \(x\) 按照权值 \(v - 1\) 分裂成 \(y\)，这个时候 \(y\) 的值全部等于 \(v\)，将 \(y\) 的根删除掉，也就是直接将 \(y\) 的 左右儿子合并起来。

inline void del(int v) {
    split(root, v, x, z), split(x, v - 1, x, y);
    y = merge(ls(y), rs(y)); root = merge(merge(x, y), z);
}

getrank 操作：

找权值为 \(v\) 的点的排名，也就是比他小的数的个数再加 \(1\)，按照 \(v - 1\) 分裂成 \(x,y\)，\(x\) 子树上的都是比他小的，再加一即为答案。

inline int getrank(int v) {
	split(root, v - 1, x, y);
	res = tr[x].siz + 1;
	root = merge(x, y); return res;
}

getnum 操作：

找排名为 \(k\) 的点的权值，从根节点出发，如果 $k\le $左子树的大小，说明了在左子树上，去左子树找，如果左子树大小加一等于 \(k\)，说明当前点为要找的点，否则去右子树找，要减去左子树大小和根节点的大小。

inline int getnum(int p, int k) {
	if(tr[ls(p)].siz >= k) return getnum(ls(p), k);
	else if(tr[ls(p)].siz + 1 == k) return p;
	else return getnum(rs(p), k - tr[ls(p)].siz - 1);
}

getpre 操作：

按照权值 \(v - 1\) 分裂成 \(x, y\)，找到 \(x\) 上最大的数。

inline int getpre(int v) {
      split(root, v - 1, x, y), res = getnum(x, tr[x].siz), root = merge(x, y); return tr[res].val;
}

getnxt 操作：

按照权值 \(v\) 分裂成 \(x, y\)，找到 \(y\) 上最小的数。

inline int getnxt(int v) {
      split(root, v, x, y), res = getnum(y, 1), root = merge(x, y);  return tr[res].val;
}