蒟蒻的笔记本四、平衡树-Treap

最新推荐文章于 2023-03-01 13:39:06 发布

语法糖likedy

最新推荐文章于 2023-03-01 13:39:06 发布

阅读量177

点赞数 1

分类专栏：树形结构文章标签：平衡树 Treap

本文链接：https://blog.csdn.net/qq_40736036/article/details/83751516

版权

树形结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

平衡树：

二叉搜索树（Binary Search Tree，BST）： 是一种数据结构，它的每一个结点都保存一个标识结点元素大小的东西----键值。对于任意结点 u，u 的左子树中的所有结点（如果存在的话）的键值都比结点 u 的键值大，u 的右子树中的所有结点（如果存在的话）的键值都比结点 u 的键值大（或等于）。

BST主要操作是：插入、删除和查找。
时间复杂度与树高有关，为O(h)，h为树高。对于给定集合，插入顺序不同树高也会有所不同，极端情况下会成为一条链，时间复杂度度为O(n)，n为元素个数，在这种情况下查找元素和线性结构没什么区别，失去了树行结构的优势。所以，平衡的BST才是实用的。

平衡二叉树（Balanced Binary Tree）： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。（来自百度百科）

让在BST保持合法（BST定义的性质）的前提下保持平衡的方法是：旋转（rotate）
BST的旋转分为两种：左旋和右旋。两种旋转原理类似，旋转对象都是根结点。
旋转（rotate）的图示：
rotate
图中红色的边为旋转前后指向关系有改变的边，不能看出，在旋转前后各结点的左右相对位置没有改变，所以依然满足是一颗BST树。

平衡树的实现方法很多，比如STL中set和map（multiset/multimap）所使用的红黑树（Red-black tree）、AVL树、替罪羊树、Treap、Splay等。
虽然有些问题使用STL就可以解决了（这种情况最好不用自己实现平衡树了），但是由于STL的过度分装，一些平衡树可以实现的功能用STL的set、map却实现不了，这时就需要自己实现平衡树。

在平衡树中，Treap的代码较简单直观，编码复杂度和时间复杂度都可观，是算法竞赛同类数据结构中的首选。（雾~~~首选什么的是看书上说的~~ ）

Treap

Treap 是一颗拥有键值、优先级两种权值的动态平衡BST树。对于键值而言，这棵树是排序二叉树，即对于这棵树任意的非空结点，左子树中健值都小于它，右子树中的键值都大于（等于）它；对于优先级而言这棵树是堆，即在这棵树的任意子树中，根节点的优先级是最大的。

Treap结点的键值与结点存储的元素本身有关，而结点的优先级是在插入时随机确定的，因为此，在某种意义上来说，各种操作的时间复杂度会是随机的，但在大量数据下Treap树会是保持平衡的，各种操作的期望时间复杂度是O(logn)的。在实际应用中也证实是如此的，实际表现的时间复杂度还是相当不错的。~~（这让我想到了快排）~~

Treap结点的定义：

//Treap结点
struct Node{
	int v,r; //键值和优先级（数值越大，优先级越高）
	Node *son[2];
	int cmp(int x) const {//自定义的比较函数 方便后续操作中的比较
		return x<v? 0:1;
	}
}

旋转 （rotate） ：

//旋转
void rotate(Node* &rt,int d){//d==0为左旋，d==1为右旋
	Node* k=rt->son[d^1];   //修改那两条红线的指向关系
	rt->son[d^1]=k->son[d];
	k->son[d]=rt;
	rt=k; //rt传的是引用，直接可以修改，不用返回
}

Treap插入：
Treap的插入只是在BST的插入上多了旋转这一步，而旋转的时机是存在不满足堆性质的时候，即当发现某个结点的子结点中有比自身优先级高的情况时。而这种情况只能在新结点插入完成时才可能出现，因此是否违背优先级的判断在递归插入操作回溯时进行。当子结点优先级大于父节点且该结点为左结点时，对父节点进行右旋操作，同理，为右结点时进行的是左旋操作。

//插入
void insert(Node* &rt,int x){ //在以rt为根的树中插入键值为x的新结点
	if(rt==NULL){ 
		rt= new Node();
		rt->son[0]=rt->son[1]=NULL;
		rt->v=x;
		rt->r=rand(); //随机优先级
	}
	else{
		int d=rt->cmp(x);
		insert(rt->son[d],x);
		if(rt->son[d]->r > rt->r) rotate(rt,d^1);//插入操作决定了旋转操作只有唯一一种可能
	}
}

Treap的查找：
查找比较简单，与BST一样

//查找
int find(Node* rt,int x){
	if(rt==NULL) return 0; //不存在
	return find(rt->son[rt->cmp(x)],x); //在子树中继续查找
}

Treap的删除：
首先找到需要删除的元素结点，然后进行删除操作：
当该结点只有一个子结点时，该结点用子结点替代即可，并且不会产生违背堆性质的情况。叶子结点也适用，相当于用空结点来取代，也就是删除了。
当该结点有两个子结点时，操作是这样的：将子结点中优先级较大的子结点通过旋转操作替换该结点成为当前子树的根结点，这时需要被删除的结点就成为了另外一边的子结点（旋转之后树的另外一颗子树的根结点），递归在另一颗子树中删除就行了。

//删除
void remove(Node* &rt,int x){ //在rt为根的子树中删除键值为x的结点
	if(rt->v==x){ //找到了x
		if(rt->son[0]==NULL) rt=rt->son[1];
		else if(rt->son[1]==NULL) rt=rt->son[0];
		else{
			int d = (rt->son[0]->r > rt->son[1]->r?1:0);
			rotate(rt,d);
			remove(rt->son[d]);
		}
	}
	else remove(rt->son[rt->cmp(x)],x);
}

简单应用：
一个很基础的应用是用Treap实现名次树。
洛谷 P3369 【模板】普通平衡树（Treap实现名次树）

题目描述
您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

插入x数
删除x数(若有多个相同的数，因只删除一个)
查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)
查询排名为x的数
求x的前驱(前驱定义为小于x，且最大的数)
求x的后继(后继定义为大于x，且最小的数)

输入格式：
第一行为nnn，表示操作的个数,下面nnn行每行有两个数opt和x，opt表示操作的序号( 1≤opt≤6 )

输出格式：
对于操作3,4,5,6每行输出一个数，表示对应答案

输入样例#1：

10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

输出样例#1：

106465
84185
492737

说明
1.时空限制：1000ms,128M
2.n的数据范围： n≤100000
3.每个数的数据范围： [-10⁷，10⁷]

平衡树实现名次树，只需要给结点新增一个成员变量size，表示以当前结点为根的子树的总结点数。结点 u 的名次（排名）就为结点 u 的左结点的size+1。

size的计算：

//sumNode为Treap结点中的成员函数
void sumNode(){ //更新rt结点的size
	size=c; //c为当前结点存在于Treap中的个数
	if(son[0]!=NULL) size+=rt->son[0]->size;
	if(son[1]!=NULL) size+=rt->son[1]->size;
}

在插入的结点可能有重复值的情况下，BST的一种处理方法是相等的值放在“右边”，而这样会对名次查询造成一些困难，一种处理方法是在结点中新增一个成员变量记录结点的值有多少个（重复了多少次）。

显然，旋转操作会导致size的改变，所以在rotate时需要更新size。

void rotate(Node* &rt,int d){//d==0为左旋，d==1为右旋
	Node* k=rt->son[d^1];  
	rt->son[d^1]=k->son[d];
	k->son[d]=rt;
	rt->sumNode(); k->sumNode(); //更新size 注意更新顺序
	rt=k; 
}

其他所有size会发生变化的情况下，都应该更新size。

AC代码：~~（蒟蒻所以代码冗长常数还大）~~

#include <iostream>
#include <cstdlib>
#include <time.h> 
#include <stdio.h>
#include <string.h>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cctype>
#include <sstream>
#define LL long long
#define _for(i,j,k) for(int i=j;i<=k;i++)
#define for_(i,j,k) for(int i=j;i>=k;i--)
#define lowbit(x) (x&-x)
#define ls(x) x<<1
#define rs(x) x<<1|1
//#pragma comment(linker, "/STACK:10240000000,10240000000")
using namespace std;
//洛谷 P3369 【模板】 普通平衡树 
const int maxn = 1e5+5;
struct Node{//tree node
    Node* son[2];
    int r,w,s,c;
    int comp(int x){
        return x<w?0:1;
    }
    void sumNode(){
        s=c;
        if(son[0]!=NULL) s+=son[0]->s;
        if(son[1]!=NULL) s+=son[1]->s;
    }
};
int minRank(Node* rt){
    //if(rt==NULL) return -1;
    int ret=1;
    if(rt->son[0]!=NULL) ret+=rt->son[0]->s;
    return ret;
}
void rotate(Node* &rt,int d){//rotate d=0左旋，d=1右旋 
    //if(rt==NULL) return ;
    Node* k=rt->son[d^1];
    rt->son[d^1]=k->son[d];
    k->son[d]=rt;
    rt->sumNode();
    k->sumNode();
    rt=k;
}
void insert(Node* &rt,int x){//insert x
    if(rt==NULL){
        rt = new Node();
        rt->son[0]=rt->son[1]=NULL;
        rt->w=x;
        rt->r=rand();
        rt->s=rt->c=1;
    }
    else if(rt->w==x){
        (rt->c)++;
    }
    else{
        int d=rt->comp(x);
        insert(rt->son[d],x);
        rt->sumNode();
        if(rt->r<rt->son[d]->r) rotate(rt,d^1); 
    }
    rt->sumNode();
}
void remove(Node* &rt,int x){//remove x
    if(rt==NULL) return;
    if(rt->w==x){
        Node* tmp=rt;
        if(rt->c>1){
            rt->c--;
        }
        else if(rt->son[0]==NULL){
            rt=rt->son[1];
            delete tmp;
        } 
        else if(rt->son[1]==NULL){
            rt=rt->son[0];
            delete tmp;
        }
        else{
            int d=(rt->son[0]->r>rt->son[1]->r?1:0);
            rotate(rt,d);
            remove(rt->son[d],x);
            rt->sumNode();
        }
    }
    else{
        int d=rt->comp(x);
        remove(rt->son[d],x);
        rt->sumNode();
    }
    if(rt!=NULL) rt->sumNode();
}
int qrank(Node* rt,int x){// return the rank of x. 
    if(rt==NULL) return -1;
    if(rt->w==x) return minRank(rt);
    else{
        int d=rt->comp(x);
        return  d*(minRank(rt)+rt->c-1)+qrank(rt->son[d],x);
    }
}
int qc(Node* rt,int x){// return the number of x. 
    if(rt==NULL) return 0;
    if(rt->w==x) return rt->c;
    else{
        int d=rt->comp(x);
        return qc(rt->son[d],x);
    }
}
int krank(Node* rt,int k){//true. return the kth number. 
    if(rt==NULL||k<=0) return 0;
    int kth=minRank(rt);
    if(k>=kth&&k<kth+rt->c) return rt->w;
    else if(k>=kth+rt->c){
        return krank(rt->son[1],k-kth-rt->c+1);
    }
    else return krank(rt->son[0],k);
}
int frank(Node* rt,int x){//return the prev number of x. 
    if(rt==NULL) return 0;
    int k=qrank(rt,x);
    return krank(rt,k-1);
}
int nrank(Node* rt,int x){//return the next number of x. 
    if(rt==NULL) return 0;
    int k=qrank(rt,x)+qc(rt,x);
    return krank(rt,k);
}
bool findNode(Node* rt,int x){
    if(rt){
        if(rt->w==x) return true;
        int d=rt->comp(x);
        if(findNode(rt->son[d],x)) return true;
    }
    return false;
}

int n,opt,num;

int main(){
    srand(time(NULL));
    Node* root=NULL;
    cin>>n;
    while(n--){
        cin>>opt>>num;
        if(opt==1){
            insert(root,num);
        }
        else if(opt==2){
            remove(root,num);
            if(root) root->sumNode();
        }
        else if(opt==3){
            cout<<qrank(root,num)<<"\n";
        }
        else if(opt==4){
            cout<<krank(root,num)<<"\n";
        }
        else if(opt==5){
            if(!findNode(root,num)){
                insert(root,num);
                cout<<frank(root,num)<<"\n";
                remove(root,num);
            }
            else cout<<frank(root,num)<<"\n";
        }
        else if(opt==6){
            if(!findNode(root,num)){
                insert(root,num);
                cout<<nrank(root,num)<<"\n";
                remove(root,num);
            }
            else cout<<nrank(root,num)<<"\n";
        }   
    }
    return 0;
}