各类动态平衡树与可持续化数据结构（坑大，不急）

最新推荐文章于 2021-03-03 21:53:32 发布
最新推荐文章于 2021-03-03 21:53:32 发布
阅读量446 收藏
点赞数
分类专栏： 待更新 总结类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42037034/article/details/81568352
版权

板子留着，有空补坑
各大常见不常用的平衡树，打的不多，但是至少要了解吧…

##Splay

  • Splay是一种十分高级的平衡树，而与一般的set或者treap不同的是，它是将多次访问的节点尽可能的靠近根的位置，从而减少查询的递归调用次数，而实现这种平衡的方式就是旋转（rotate）了。各个步骤的详解请参看博客 博客详解传送门。每一块都讲的比较的详细，而相应的例题就到各大OJ上去找找吧…
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
inline int read(){
    int X=0,w=0; char c=0;
    while(c<'0'||c>'9') {w|=c=='-';c=getchar();}
    while(c>='0'&&c<='9') X=(X<<3)+(X<<1)+(c^48),c=getchar();
    return w?-X:X;
}
struct node{
	int value;
	node *father,*son[2];
	node(int v=0,node *f=NULL){value =v;father=f;son[0]=NULL;son[1]=NULL;}
}*root;
inline bool son(node *f,node *s){return f->son[1]==s;}
inline void rotate(node *t){
	node *f=t->father;
	node *g=f->father;
	bool a=son(f,t),b=!a;
	f->son[a]=t->son[b];
	if(t->son[b]!=NULL) t->son[b]->father=f;
	t->son[b]=f;f->father=t;t->father=g;
	if(g!=NULL) g->son[son(g,f)]=t; else root=t;
}
inline void splay(node *t,node *p){
	while (t->father!=p){
		node *f=t->father;
		node *g=f->father;
		if(g==p) rotate(t);
		else if(son(g,f)^son(f,t)) rotate(t),rotate(t);
				else rotate(f),rotate(t);
	}
}
inline void insert(int val){
	if(root==NULL)root=new node(val,NULL);
	for (node *t=root;t;t=t->son[val>t->value]){
		if(t->value==val){splay(t,NULL);return;}
		if(t->son[val>=t->value]==NULL) t->son[val>=t->value]=new node(val,t);
	}
}
inline void erase(int val){
	node *t=root;
	for (;t;){
		if(t->value==val) break;
		t=t->son[val>t->value];
	}
	if(t!=NULL){
		splay(t,NULL);
		if(t->son[0]==NULL){
			root->son[1];
			if(root!=NULL) root->father=NULL;
		}else{
			node *p=t->son[0];
			while (p->son[1]!=NULL)p=p->son[1];
			splay(p,t);root=p;
			root->father=NULL;
			p->son[1]=t->son[1];
			if(p->son[1]!=NULL) p->son[1]->father=p;
		}
	}
}
int main(){
	
}

##替罪羊树（Scapegoat_Tree）
没基础的小伙伴往这里走：博客传送门代码清晰思路干净，不可多得的一篇好博文。

  • emmm，也是一种十分神奇的平衡树，有三个特点：
  • 1、实现平衡的方式不是旋转，而是直接将不平衡的子树拍散，拉成一条链，从中间二分出一棵新的平衡子树。暴力而优美。
  • 2、判断是否平衡也是利用一个随机数值 $ alpha $ 来实现是否达到平衡，而 a l p h a alpha alpha的选值会对平衡重构的次数与查询次数有所影响。所以比较玄学。
  • 3、判断删除时并不是真正的将他删除，而是定义boollean叫cover来判断是否激活从而进行运算。
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#define LL long long
using namespace std;
inline int read(){
    int X=0,w=0; char c=0;
    while(c<'0'||c>'9') {w|=c=='-';c=getchar();}
    while(c>='0'&&c<='9') X=(X<<3)+(X<<1)+(c^48),c=getchar();
    return w?-X:X;
}
namespace Scapegoat_Tree{
	#define MAXN (100000 + 10)
	const double alpha =0.75;
	struct Node{
		Node *ch[2];
		int key,size,cover;
		bool exist;
		void PushUp(void){
			size=ch[0]->size+ch[1]->size+(int)exist;
			cover=ch[0]->cover+ch[1]->cover+1;
		}
		bool isBad(void){
			return ((ch[0]->cover>cover*alpha+5)||(ch[1]->cover>cover*alpha+5));
		}
	};
	struct Stree{
		protected:
			Node mem_poor[MAXN];
			Node *tail,*root,*null;
			Node *bc[MAXN];int bc_top;
			Node *NewNode(int key){
				Node *p=bc_top?bc[--bc_top]:tail++;
				p->ch[0]=p->ch[1]=null;
				p->size=p->cover=1;
				p->exist=true;
				p->key=key;
				return p;
			}
			void Travel(Node *p, vector<Node *> &v){
				if(p==null) return;
				Travel(p->ch[0],v);
				if(p->exist) v.push_back(p);
				else bc[bc_top++]=p;
				Travel(p->ch[1],v);
			}
			Node *Divide(vector<Node*>v,int l,int r){
				if(l>=r) return null;
				int mid=(l+r)>>1;
				Node *p=v[mid];
				p->ch[0]=Divide(v,l,mid);
				p->ch[1]=Divide(v,mid+1,r);
				p->PushUp();
				return p;
			}
			void Rebuild(Node * &p){
				static vector <Node *>v;v.clear();
				Travel(p,v);p=Divide(v,0,v.size());
			}
			Node **Insert(Node *&p, int val){
				if(p==null){
					p=NewNode(val);
					return &null;
				}else{
					p->size++;p->cover++;
					Node ** res=Insert(p->ch[val>=p->key],val);
					if(p->isBad()) res=&p;
					return res;
				}
			}
			void Erase(Node *p,int id){
				p->size--;
				int offset=p->ch[0]->size+p->exist;
				if(p->exist&&id==offset){
					p->exist=false;
					return;
				}else{
					if(id<=offset) Erase(p->ch[0],id);
					else Erase(p->ch[1],id-offset);
				}
			}
		public:
			void Init(void){
				tail=mem_poor;
				null=tail++;
				null->ch[0]=null->ch[1]=null;
				null->cover=null->size=null->key=0;
				root=null;bc_top=0;
			}
			Stree(void){Init();}
			
			void Insert(int val){
				Node **p=Insert(root,val);
				if(*p!=null) Rebuild(*p);
			}
			int Rank(int val){
				Node *now=root;
				int ans=1;
				while (now!=null){
					if(now->key>=val) now=now->ch[0];
					else{
						ans+=now->ch[0]->size+now->exist;
						now=now->ch[1];
					}
				}
				return ans;
			}
			int Kth(int k){
				Node *now=root;
				while(now!=null){
					if(now->ch[0]->size+1==k&&now->exist) return now->key;
					else if(now->ch[0]->size>=k) now=now->ch[0];
					else k-=now->ch[0]->size+now->exist,now=now->ch[1];
				}
			}
			void Erase(int k){
				Erase(root,Rank(k));
				if(root->size<alpha*root->cover) Rebuild(root);
			}
			void Erase_Kth(int k){
				Erase(root,k);
				if(root->size<alpha*root->cover) Rebuild(root);
			}
	};
	#undef MAXN
}
int main(){
    
}

##主席树

  • 第一个可持久化数据结构，其实本质是可持久化线段树。学习请参考求区间第k大//主席树
  • 实际上是由多个线段树的叠加组成的，而线段树上所记录的权值是当前子树所包含的离散数据的个数（看上去好像很绕），每插入一个元素就会生成一颗新的线段树，换句话说就是空间换时间吧…
  • 主席树的特点就是可以进行前后状态的加减，从而达到区间的查询，而这里的加减是指对于每一个节点上的权值的相应加减。下面的板子是静态的主席树…不可以修改的…
  • 动态的主席树还需要用到树状数组来进行维护和查询orz…但是我真的不会…
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#define LL long long
using namespace std;
inline int read(){
    int X=0,w=0; char c=0;
    while(c<'0'||c>'9') {w|=c=='-';c=getchar();}
    while(c>='0'&&c<='9') X=(X<<3)+(X<<1)+(c^48),c=getchar();
    return w?-X:X;
}
const int N=200010,LOG=30;
int n,m,q,tot;
int a[N],b[N];
int T[N],sum[N*LOG],L[N*LOG],R[N*LOG];
inline int build(int l,int r){
	int rt=++tot;
	if(l<r){
		int mid=(l+r)>>1;
		L[rt]=build(l,mid);
		R[rt]=build(mid+1,r);
	}
	return rt;
}
inline int update(int pre,int l,int r,int x){
	int rt=++tot;
	L[rt]=L[pre],R[rt]=R[pre];sum[rt]=sum[pre]+1;
	if(l<r){
		int mid=(l+r)>>1;
		if(x<=mid) L[rt]=update(L[pre],l,mid,x);
		else R[rt]=update(R[pre],mid+1,r,x);
	}
	return rt;
}
inline int query(int u,int v,int l,int r,int k){
	if(l==r) return l;
	int x=sum[L[v]]-sum[L[u]];
	int mid=(l+r)>>1;
	if(x>=k) return query(L[u],L[v],l,mid,k);
	else return query(R[u],R[v],mid+1,r,k-x);
}
int main(){
    tot=0;
	memset(T,0,sizeof(T));memset(sum,0,sizeof(sum));
	memset(L,0,sizeof(L));memset(R,0,sizeof(R));
	n=read(),q=read();
	for (int i=1;i<=n;i++) a[i]=read(),b[i]=a[i];
	sort(b+1,b+n+1);
	m=unique(b+1,b+n+1)-b-1;
	T[0]=build(1,m);
	for (int i=1;i<=n;i++){
		a[i]=lower_bound(b+1,b+m+1,a[i])-b;
		T[i]=update(T[i-1],1,m,a[i]);
	}
	while (q--){
		int x,y,z;
		x=read(),y=read(),z=read();
		int p=query(T[x-1],T[y],1,m,z);
		printf("%d\n",b[p]);
		
	}
}

##treap（带旋）

  • 下面贴的是洛谷P3369的板子，亲测有效orz
  • 其实treap是最朴实的二叉平衡树了。只有旋转，尽量使树保持平衡，但又没有替罪羊树这么的暴力。~~（当年写的板子代码结构真的丑）~~就当个手打的set抄抄吧_(:з」∠)_
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
using namespace std;
const int N=100010;
int n,cnt;
struct node{
    node *L,*R;
    int fix,val,size;
    void init(){
        L=R=NULL;
    }
    inline int lsize(){return L?L->size:0;}
    inline int rsize(){return R?R->size:0;}
}Tree[N],*root;
node *New_node(){
    Tree[cnt].init();
    return Tree+cnt++;
}
void recount(node *&p){
    p->size=p->lsize()+p->rsize()+1;
}
void L_rot(node *&a){
    node *b=a->R;
    a->R=b->L;
    b->L=a;
    a=b;
    recount(a->L);
    recount(a);
}
void R_rot(node *&a){
    node *b=a->L;
    a->L=b->R;
    b->R=a;
    a=b;
    recount(a->R);
    recount(a);
}
void insert(node *&p,int val){
    if(!p){
        p=New_node();
        p->val=val;
        p->size=1;
        p->fix=rand();
    }else if(val<=p->val){
        p->size++;
        insert(p->L,val);
        if(p->L->fix<p->fix){
            R_rot(p);
        }
    }else{
        p->size++;
        insert(p->R,val);
        if(p->R->fix<p->fix){
            L_rot(p);
        }
    }
}
void Delete(node *&p,int val){
    if(val==p->val){
        if(!p->L||!p->R){
            if(p->L) 
                p=p->L;
            else
                p=p->R;
        }else if(p->L->fix<p->R->fix){
            R_rot(p);
            p->size--;
            Delete(p->R,val);
        }else{
            L_rot(p);
            p->size--;
            Delete(p->L,val);
        }
    }else if(val<p->val){
        p->size--;
        Delete(p->L,val);
    }else{
        p->size--;
        Delete(p->R,val);
    }
}
int Rank(node *p,int val){
    if(!p) return 0;
    if(val>p->val){
        return p->lsize()+Rank(p->R,val)+1;
    }else{
        return Rank(p->L,val);
    }
}
int Find(node *p,int rank){
    if(p->lsize()+1==rank) return p->val;
    if(p->lsize()+1>rank) return Find(p->L,rank);
    return Find(p->R,rank-p->lsize()-1);
}
int query_pre(node *p,int val,int now){
    if(!p) return now;
    if(p->val<val) return query_pre(p->R,val,p->val);
    return query_pre(p->L,val,now);
}
int query_after(node *p,int val,int now){
    if(!p) return now;
    if(p->val>val) return query_after(p->L,val,p->val);
    return query_after(p->R,val,now);
}
int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        int t,d;
        scanf("%d%d",&t,&d);
        if(t==1){insert(root,d);continue;}
        if(t==2){Delete(root,d);continue;}
        if(t==3){printf("%d\n",Rank(root,d)+1);continue;}
        if(t==4){printf("%d\n",Find(root,d));continue;}
        if(t==5){printf("%d\n",query_pre(root,d,root->val));continue;}
        if(t==6){printf("%d\n",query_after(root,d,root->val));continue;}
    }
    return 0;
}

###动态树（link-cut-tree）

#include <bits/stdc++.h>
using namespace std;
namespace link_cut_tree{
	#define maxn 100000
	struct node{
		int fa,ch[2];
		bool reverse,is_root;
	}T[maxn];
	struct LCT{
		protected://splay部分 
			int Getson(int x){return x==T[T[x].fa].ch[1];}
			void Push_Reverse(int x){
				if(!x) return;
				swap(T[x].ch[0],T[x].ch[1]);
				T[x].reverse^=true;
			}
			void Push_Down(int x){
				if(T[x].reverse){
					Push_Reverse(T[x].ch[0]);
					Push_Reverse(T[x].ch[1]);
					T[x].reverse=false;
				}
			}
			void Rotate(int x){
				if(T[x].is_root) return;
				int k=Getson(x),f=T[x].fa;
				int g=T[f].fa;
				Push_Down(f);Push_Down(x);
				T[f].ch[k]=T[x].ch[k^1];
				if(T[x].ch[k^1]) T[T[x].ch[k^1]].fa=f;
				T[x].ch[k^1]=f;
				T[f].fa=x;
				T[x].fa=g;
				if(!T[f].is_root) T[g].ch[f==T[g].ch[1]]=x;
				else T[x].is_root=true,T[f].is_root=false;
				//Updata(f);Updata(x);
			}
			void Push(int x){
				if(!T[x].is_root)Push(T[x].fa);
				Push_Down(x);
			}
			void Splay(int x){
				Push(x);
				for (int fa;!T[x].is_root;Rotate(x)){
					fa=T[x].fa;
					if(!T[fa].is_root){
						if (Getson(x)==Getson(fa))Rotate(fa);
						else Rotate(x);
					}
				}
			}
		public:
			void Access(int x){
				int y=0;
				do{
					Splay(x);
					T[T[x].ch[1]].is_root=true;
					T[x].ch[1]=y;
					T[T[x].ch[1]].is_root=false;
					//Updata(x);
					y=x;
					x=T[y].fa;
				}while(x);
			}
			void Mroot(int x){
				Access(x);
				Splay(x);
				Push_Reverse(x);
			}
			void Link(int u,int v){
				Mroot(u);
				T[u].fa=v;
			}
			void cut(int u,int v){
				Mroot(u);
				Access(v);Splay(v);
				Push_Down(v);
				T[u].fa=T[v].ch[0]=0;
			}
	};
	#undef maxn
}
int main(){
	
}
朝阳的二愣子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
离线可持久化动态树
weixin_30271335的博客
03-08 148
　　不,你想多了,我并没有发明.　　 　　动态树?我会LCT! 　　然后加上在线和可持久化的前缀,这道题就变得面目可憎了起来. 　　对于一个森林,刚开始没有边.你需要维护下面的操作. 　　操作1:给定x,y,令x的父亲为y. 　　操作2:给定t,x,k,求第t个版本中x的第k个祖先.如果没有输出0. 　　操作3:给定t,x,求第t个版本中x的深度. 　　20%:n&lt...
字典树（Trie树）附例题（统计难题 HDU - 1251+Xor Sum HDU - 4825）
Vici__
11-05 240
一、基础理论：        字典树，又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 二、基本性质： 根节点不包含字符，除根节点之外每个子节点都包含一个字符。 从根节点开始到某一终止节点，路径上的字符连接起来，就是该终止节点对应的字符串。 每个终止节点代表的字符串都是...
【洛谷P4719】动态DP（全局平衡二叉树）
CaptainChen的博客
03-23 505
题目大意 给定一棵n个点的树，点带点权。 有m次操作，每次操作给定x,y，表示修改点x的权值为y。 你需要在每次操作之后求出这棵树的最大权独立集的权值大小。 题解 如果不带修改操作，正常的DP式： dp[u][1]dp[u][1]dp[u][1]表示当前结点保证选择，这个结点的子树独立集最大权值。 dp[u][0]dp[u][0]dp[u][0]表示当前结点不选择，这个结点的子树独立集最大权值。 ...
范浩强_wc2012谈谈各种数据结构
10-30
……看之前要先orz一下…… 大概他是可持久化编程的提出者？
进化版数据结构（可持久化）
cdy1206473601的博客
05-24 1086
主席树和可持久化线段树有什么区别？ 总之没什么区别！！ 主席树（可持久化线段树） 可持久化线段树（Persistent data structure）最主要的功能就是可以查询历史版本。那么presistent≈president（主席），得名主席树。 给你个问题： 给你一段数列，要求查询一段区间的第k小数。(n&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp
数字化碳排放解决方案167.docx
05-05
数字化碳排放解决方案是一种利用现代信息...总的来说，数字化碳排放解决方案V3.0旨在通过技术创新和精细化管理，推动企业或城市的能源使用更加高效、环保，实现碳排放的降低，符合国家的节能减排政策和可持续发展目标。
云计算数据中心建设要点v1.pptx
10-10
- **大数据**：处理海量非结构化数据，挖掘潜在价值。 - **移动计算**：随着移动设备的普及，数据中心需支持多平台接入。 - **社交网络**：整合社交数据，提升用户交互体验。 总之，云计算数据中心的建设需结合...
电力系统中自动化技术的应用及发展方向 (1).pdf
08-28
总结来说，电力系统自动化技术的应用及发展方向涵盖了智能化、网络化、集成化、绿色化、自适应等多个方面，这些发展趋势将极大地推动电力行业的现代化进程，提升电力服务的质量和效率，保障社会经济的可持续发展。...
2575.2021年差容式力平衡传感器行业生产部门模板汇总 .pdf
09-29
在2021年的差容式力平衡传感器行业中，生产部门扮演着至关重要的角色，而这份2021年差容式力平衡传感器行业生产部门模板汇总，详细列出了各类管理表格，旨在优化生产流程，提升部门效率。以下是其中涉及的关键知识点...
2021-2022年收藏的精品资料高校档案资源管理信息化建设的困境及其对策.doc
最新发布
12-13
为了克服这些困境，高校应加大对档案管理信息化建设的投入，培养专业化的档案管理人员，采用先进的信息技术手段，如云计算、大数据分析等，对档案资源进行数字化、结构化处理，提升档案的检索速度和利用效率。...
【模板】可持久化平衡树（非旋Treap）
远行客
03-23 1362
洛谷传送门：【模板】可持久化平衡树 题意 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作（对于各个以往的历史版本）： 1.插入x数 2.删除x数(若有多个相同的数，因只删除一个，如果没有请忽略该操作) 3.查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名) 4.查询排名为x的数 5.求x的前驱(前驱定义为小于x...
*分享-神奇的MLE原因-为什么结构体开的内存不大却MLE？用数组开更大还能ac？？？
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
05-24 6061
今天写了一道题，ac之后想看一下我的代码数据量最大可以开到多少。 出乎意料的是，我把结构体数据稍开大一点就MLE？？？ 非常不解，在网上找了别人的代码测试一下，结构就出现了下面的情况。 ps:xjb数组是测试用的，没啥用。。。但是居然还是ac了。 十分不解。虽然说知道结构体是内存对齐储存。 但是也不应该出现这种情况呀？？第二段代码开longlong都没事啊？ 大佬说可...
数据结构常见题目
热门推荐
gaibian_one的博客
09-13 2万+
链表 当删除一个节点时，并不一定要删除这个节点本身，可以把下一个节点的内容复制出来覆盖被删除节点的内容，然后把下一个节点删除。（提高单链表的删除效率，不用从头遍历链表，但删除的是最后一个节点时，仍需要从头遍历到前一个节点） 当我们用一个指针遍历链表不能解决问题时，可以尝试用两个指针遍历链表，让其中一个指针遍历的快一些。 如：（1）链表倒数第k个节点        思路：两个指针间隔k-1，
主席树（可持续化线段树）
zqh_wz
09-17 700
我们知道，线段树可以在O(logn)O(logn)时间内完成区间（单点）更新，区间求极值与区间求和。 但是，对于下面这个问题： 给定一个长度为nn的序列，有mm个询问，对于每个询问，输出区间[L,R][L,R]中的第KK大的值。(n,m<=100000)(n,m<=100000) 对于这个问题 ，似乎单纯的线段树并不能解决。 先让我们来考虑一个简单的问题： 给定一个区间，求出这个区间中的
数据结构： 平衡二叉树
runfeel
10-27 216
一、定义 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用算法有红黑树、AVL、Treap、伸展树等。 平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了...
java动态平衡_java-实现平衡二叉树
weixin_33694391的博客
02-13 159
1，前面一条博客实现了，二叉查找树，但是当二叉树退化成链表后，二叉查找树的时间复杂度优越性就没有了，再网上学习了一下，啊啊啊，调了一夜bug，5555主要参考博主的博客：https://www.cnblogs.com/qm-article/p/9349681.html实现平衡二叉树是基于，二叉查找树的，所以建议先写一遍二叉查找树，再学二叉平衡操作原理，把自己的二叉查找树变成，平衡二叉树。(可以一步...
Rope大法（可持久化平衡树）
piaocoder
09-25 3328
2008年OI集训论文上有介绍，其主要是结合了链表和数组各自的优点，链表中的节点指向每个数据块，即数组，并且记录数据的个数，然后分块查找 和插入。在g++头文件中，中有成型的块状链表，在using namespace __gnu_cxx;空间中，其操作十分方便。 　　基本操作： rope test; test.push_back(x);//在末尾添加x test.insert(pos
可持久化数据结构——学习笔记
cym_的博客
03-03 125
可持久化前提： 本身的拓扑结构不改变 （平衡树左右旋，拓扑结构改变，不可持久化） 核心思想： 存下数据结构的所有历史版本时，只记录每个版本与前一个版本 改变的部分，每次新增部分至多log(n)个节点，m次为mlog(n) 可持久化trie： 算法步骤： 1、插入：枚举str的每一位，当前位s[i]新建一个节点，当前位的其余字符都与上一版本相同，直接copy 2、查询：查询(l,r)的某个信息时，利用历史版本的可减性，®-(l-1)得到区间(l,r)的信息 P4735 最大异或和 题意：在前缀和{S[i]}中
对六种平衡树的研究与探索【全面】【更新中】
lemonoil的博客
02-10 1万+
对平衡树的研究与探索四川省第七中学（高新校区） 李明洋 对平衡树的研究与探索 摘要 关键字 二叉搜索树 treap splay sbt rbt 替罪羊树 AVL 正文 一引言 二各类平衡树的基本介绍 平衡二叉树 treap 基本介绍 补充 替代rand 可持久化 核心的步骤 旋转 插入删除和选择第k小项 操作及模板 sbt节点大小平衡树 基本介绍 补充 与标准版的比较 插入人字形数据后退化的SBT

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值