小结-Splay

最新推荐文章于 2022-03-20 18:57:22 发布
最新推荐文章于 2022-03-20 18:57:22 发布
阅读量105 收藏
点赞数
原文链接：http://www.cnblogs.com/abclzr/p/5248384.html
版权

参照陈竞潇学长的模板写的BZOJ 3188：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define for1(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef long long ll;
const int N=1E5+100;
int n,m,data[N];
struct node{
    node();
    node *ch[2],*fa;
    ll d,sum,set,add[2]; int size; short vset;
    short pl() {return this==fa->ch[1];}
    void count(); void push();
    void mark(ll,ll,short);
}*null;
node::node(){ch[0]=ch[1]=fa=null; size=vset=sum=add[0]=add[1]=0;}
void node::mark(ll val,ll dd,short t){
    if(this==null) return;
    if(!t){
        set=val;
        sum=size*set;
        d=set;
        vset=1;
        add[0]=add[1]=0;
    }else{
        add[0]+=val;
        add[1]+=dd;
        sum+=val*size;
        sum+=dd*size*(size-1)/2;
        d+=val+dd*(ch[0]->size);
    } 
}
void node::push(){
    if(this==null)return;
    if(vset){
        ch[0]->mark(set,0,0);
        ch[1]->mark(set,0,0);
        vset=0; set=0;
    }
    if(add[0]||add[1]){
        ch[0]->mark(add[0],add[1],1);
        ch[1]->mark(add[0]+add[1]*(ch[0]->size+1),add[1],1);
        add[0]=add[1]=0;
    }
}
void node::count(){
    size=ch[0]->size+ch[1]->size+1;
    sum=ch[0]->sum+ch[1]->sum+d;
}
namespace Splay{
    node *ROOT;
    node *build(int l=1,int r=n){
        if (l>r) return null;
        int mid=(l+r)>>1;
        node *ro=new node;
        ro->d=data[mid];
        ro->ch[0]=build(l,mid-1);
        ro->ch[1]=build(mid+1,r);
        ro->ch[0]->fa=ro;
        ro->ch[1]->fa=ro;
        ro->count();
        return ro;
    }
    void Build(){
        null=new node;
        *null=node();
        ROOT=build();
    }
    void rotate(node *k){
        node *r=k->fa; if (k==null||r==null) return;
        r->push(); k->push();
        int x=k->pl()^1;;
        r->ch[x^1]=k->ch[x];
        r->ch[x^1]->fa=r;
        if (r->fa!=null) r->fa->ch[r->pl()]=k;
        else ROOT=k;
        k->fa=r->fa; r->fa=k;
        k->ch[x]=r;
        r->count(); k->count();
    }
    void splay(node *r,node *tar=null){
        for (;r->fa!=tar;rotate(r))
         if (r->fa->fa!=tar)rotate(r->pl()==r->fa->pl()?r->fa:r);
        r->push();
    }
    void insert(int x,int val){
        node *r=ROOT;
        if (ROOT==null){
            ROOT=new node;
            ROOT->d=val;
            ROOT->count();
            return;
        }
        while (1)
        {
            r->push();
            int c;
            if (r->ch[0]->size+1>=x) c=0;
            else c=1,x-=r->ch[0]->size+1;
            if (r->ch[c]==null){
                r->ch[c]=new node;
                r->ch[c]->fa=r;
                r->ch[c]->d=val;
                splay(r->ch[c]);
                return;
            }else r=r->ch[c];
        }
    }
    node *kth(int k){
        node *r=ROOT;
        while (r!=null){
            r->push();
            if (r->ch[0]->size>=k) r=r->ch[0];
            else if (r->ch[0]->size+1>=k) return r;
            else k-=r->ch[0]->size+1,r=r->ch[1];
        }
        return null;
    }
    node *pack(int l,int r){
        node *ln=kth(l-1),*rn=kth(r+1);
        if ((ln==null)&&(rn==null)) return ROOT;
        else if (ln==null){
            splay(rn); return rn->ch[0];
        }else if (rn==null){
            splay(ln); return ln->ch[1];
        }else{
            splay(ln); splay(rn,ROOT);
            return rn->ch[0];
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for1(i,1,n)scanf("%d",&data[i]);
    Splay::Build(); int j,a,b,c;
    for1(i,1,m){
        scanf("%d",&j);
        switch(j){
            node *r;
            case 1:
                scanf("%d%d%d",&a,&b,&c);
                r=Splay::pack(a,b);
                r->mark(c,0,0);
                Splay::splay(r);
            break;
            case 2:
                scanf("%d%d%d",&a,&b,&c);
                r=Splay::pack(a,b);
                r->mark(c,c,1);
                Splay::splay(r);
            break;
            case 3:
                scanf("%d%d",&a,&b);
                Splay::insert(a,b);
            break;
            case 4:
                scanf("%d%d",&a,&b);
                r=Splay::pack(a,b);
                printf("%lld\n",r->sum);
            break;
        }
    }
    return  0;
}

 还是参照陈竞潇学长的模板写的指针版的BZOJ 3224普通平衡树：

#include<cctype>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define for1(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef long long ll;
struct node{
    node();
    node *ch[2],*fa;
    int d,size,sum;
    short pl(){return this==fa->ch[1];}
    void count(){sum=ch[0]->sum+ch[1]->sum+size;}
}*null;
node::node(){ch[0]=ch[1]=fa=null;size=sum=0;}
int getint(){
    char c; int fh=1;
    while (!isdigit(c=getchar()))
     if (c=='-') fh=-1;
    int a=c-'0';
    while (isdigit(c=getchar()))
     a=a*10+c-'0';
    return a*fh;
}
namespace Splay{
    node *ROOT;
    void Build(){
        null=new node;
        *null=node();
        ROOT=null;
    }
    void rotate(node *k){
        node *r=k->fa; if (k==null||r==null) return;
        int x=k->pl()^1;
        r->ch[x^1]=k->ch[x];
        r->ch[x^1]->fa=r;
        if (r->fa!=null) r->fa->ch[r->pl()]=k;
        else ROOT=k;
        k->fa=r->fa; r->fa=k;
        k->ch[x]=r;
        r->count(); k->count();
    }
    void splay(node *r,node *tar=null){
        for (;r->fa!=tar;rotate(r))
         if (r->fa->fa!=tar) rotate(r->pl()==r->fa->pl()?r->fa:r);
    }
    void updata(node *r){
        while (r!=null){
            r->count();
            r=r->fa;
        }
    }
    void insert(int x){
        node *r=ROOT;
        if (ROOT==null){
            ROOT=new node;
            ROOT->d=x;
            ROOT->size=1;
            ROOT->sum=1;
            return;
        }
        while (1){
            int c;
            if (x<r->d) c=0;
            else if (x>r->d) c=1;
            else {r->size++;r->sum++;splay(r); return;}
            if (r->ch[c]==null){
                r->ch[c]=new node;
                r->ch[c]->fa=r;
                r->ch[c]->d=x;
                r->ch[c]->size=1;
                r->ch[c]->sum=1;
                splay(r->ch[c]);
                return;
            }else r=r->ch[c];
        }
    }
    node *kth(int k){
        node *r=ROOT;
        while (r!=null){
            if (r->ch[0]->sum>=k) r=r->ch[0];
            else if (r->ch[0]->sum+r->size>=k) return r;
            else k-=r->ch[0]->sum+r->size,r=r->ch[1];
        }
        return null;
    }
    node *ques(int k){
        node *r=ROOT; int ans=0;
        while (r!=null){
            if (k<r->d) r=r->ch[0];
            else if (k>r->d) ans+=r->ch[0]->sum+r->size,r=r->ch[1];
            else {printf("%d\n",ans+r->ch[0]->sum+1); return r;}
        }
        return null;
    }
    node *ques2(int k){
        node *r=ROOT;
        while (r!=null){
            if (k<r->d) r=r->ch[0];
            else if (k>r->d) r=r->ch[1];
            else return r;
        }
        return null;
    }
    node *rightdown(node *r){
        while (r->ch[1]!=null){
            r=r->ch[1];
        }return r;
    }
    node *leftdown(node *r){
        while (r->ch[0]!=null){
            r=r->ch[0];
        }return r;
    }
    void deleter(node *r){
        if (r->size>1){
            splay(r);
            r->size--; r->sum--; return;
        }else{
            splay(r);
            if ((r->ch[0]==null)&&(r->ch[1]==null)){
                ROOT=null;
                delete r;
            }else if (r->ch[0]==null){
                r->ch[1]->fa=null;
                ROOT=r->ch[1];
                delete r;
            }else if (r->ch[1]==null){
                r->ch[0]->fa=null;
                ROOT=r->ch[0];
                delete r;
            }else{
                splay(rightdown(r->ch[0]),ROOT);
                r->ch[0]->ch[1]=r->ch[1];
                r->ch[1]->fa=r->ch[0];
                r->ch[0]->fa=null;
                r->ch[0]->count();
                ROOT=r->ch[0];
                delete r;
            }
        }
    }
    int predd(node *r,int x){
        if (r==null) return -1E7-10;
        if (x<=r->d) return predd(r->ch[0],x);
        return max(r->d,predd(r->ch[1],x));
    }
    int pross(node *r,int x){
        if (r==null) return 1E7+10;
        if (r->d<=x) return pross(r->ch[1],x);
        return min(r->d,pross(r->ch[0],x));
    }
    int predds(int x){
        return predd(ROOT,x);
    }
    int prosss(int x){
        return pross(ROOT,x);
    }
}
int main()
{
    int n,x,num;
    n=getint();
    Splay::Build();
    while (n>0){n--;
        x=getint();
        switch(x){
            node *r;
            case 1:
                num=getint();
                Splay::insert(num);
            break;
            case 2:
                num=getint();
                r=Splay::ques2(num);
                Splay::deleter(r);
            break;
            case 3:
                num=getint();
                r=Splay::ques(num);
            break;
            case 4:
                num=getint();
                r=Splay::kth(num);
                printf("%d\n",r->d);
            break;
            case 5:
                num=getint();
                printf("%d\n",Splay::predds(num));
            break;
            case 6:
                num=getint();
                printf("%d\n",Splay::prosss(num));
            break;
        }
    }
    return 0;
}

还是参照陈竞潇学长的模板写的BZOJ 3224普通平衡树，数组版，效率和指针版的差不多，但更短，也许是我压代码了吧，，，

#include<cstdio>
#include<algorithm>
#define read(x) x=getint()
using namespace std;
inline const int getint(){char c=getchar();int k=1,r=0;for(;c<'0'||c>'9';c=getchar())if(c=='-')k=-1;for(;c>='0'&&c<='9';c=getchar())r=r*10+c-'0';return k*r;}
struct node{
	int fa,ch[2],d,size,sum;
}T[100003];
int chi[100003],top=0,cnt=1,ROOT=0;
inline bool pl(int X){return T[T[X].fa].ch[1]==X;}
inline void newnode(int &X){
	if (top) {X=chi[top];top--;} else X=cnt++;
	T[X].fa=T[X].ch[0]=T[X].ch[1]=T[X].d=T[X].size=T[X].sum=0;
}
inline void count(int k){T[k].sum=T[T[k].ch[0]].sum+T[T[k].ch[1]].sum+T[k].size;}
inline void rotate(int k){
	int r=T[k].fa; if (k==0||r==0) return;
	int x=pl(k)^1;
	T[r].ch[x^1]=T[k].ch[x];
	T[T[r].ch[x^1]].fa=r;
	if (T[r].fa!=0) T[T[r].fa].ch[pl(r)]=k;
	else ROOT=k;
	T[k].fa=T[r].fa; T[r].fa=k; T[k].ch[x]=r;
	count(r); count(k);
}
inline void splay(int k,int tar=0){
	for(;T[k].fa!=tar;rotate(k))
		if (T[T[k].fa].fa!=tar) rotate(pl(k)==pl(T[k].fa)?T[k].fa:k);
}
inline void insect(int x){
	int k=ROOT;
	if (ROOT==0){
		newnode(ROOT);
		T[ROOT].d=x; T[ROOT].size=T[ROOT].sum=1;
		return;
	}
	while (1){
		int c;
		if (x<T[k].d) c=0;
		else if (x>T[k].d) c=1;
			 else {T[k].size++;T[k].sum++;splay(k);return;}
		if (T[k].ch[c]==0){
			newnode(T[k].ch[c]);
			T[T[k].ch[c]].fa=k;
			T[T[k].ch[c]].d=x;
			T[T[k].ch[c]].size=1;
			T[T[k].ch[c]].sum=1;
			splay(T[k].ch[c]);
			return;
		}else k=T[k].ch[c];
	}
}
inline void del(int x){top++; chi[top]=x;}
inline int rightdown(int x){
	while (T[x].ch[1]!=0) x=T[x].ch[1];
	return x;
}
inline void deletr(int x){
	int k=ROOT;
	while (k){
		if (x<T[k].d) k=T[k].ch[0];
		else if (x>T[k].d) k=T[k].ch[1];
			 else break;
	}if (k==0) return;
	if (T[k].size>1){
		splay(k);
		T[k].size--;T[k].sum--;return;
	}else{
		splay(k);
		if ((T[k].ch[0]==0)&&(T[k].ch[1]==0)){
			ROOT=0; del(k);
		}else if (T[k].ch[0]==0){
			T[T[k].ch[1]].fa=0;
			ROOT=T[k].ch[1];
			del(k);
		}else if (T[k].ch[1]==0){
			T[T[k].ch[0]].fa=0;
			ROOT=T[k].ch[0];
			del(k);
		}else{
			splay(rightdown(T[k].ch[0]),ROOT);
			T[T[k].ch[0]].ch[1]=T[k].ch[1];
			T[T[k].ch[1]].fa=T[k].ch[0];
			T[T[k].ch[0]].fa=0;
			count(T[k].ch[0]);
			ROOT=T[k].ch[0];
			del(k);
		}
	}
}
inline void query(int x){
	int k=ROOT,s=0;
	while (k){
		if (x<T[k].d) k=T[k].ch[0];
		else if (x>T[k].d) s+=T[T[k].ch[0]].sum+T[k].size,k=T[k].ch[1];
			 else break;
	}printf("%d\n",s+T[T[k].ch[0]].sum+1);
}
inline void queryk(int x){
	int k=ROOT;
	while (k){
		if (T[T[k].ch[0]].sum>=x) {k=T[k].ch[0];}
		else {if (T[T[k].ch[0]].sum+T[k].size>=x) break;
			 else x-=T[T[k].ch[0]].sum+T[k].size;k=T[k].ch[1];}
	}printf("%d\n",T[k].d);
}
inline int pre(int k,int x){
	if (k==0) return -1E7-10;
	if (x<=T[k].d) return pre(T[k].ch[0],x);
	return max(pre(T[k].ch[1],x),T[k].d);
}
inline int pro(int k,int x){
	if (k==0) return 1E7+10;
	if (T[k].d<=x) return pro(T[k].ch[1],x);
	return min(pro(T[k].ch[0],x),T[k].d);
}
int main(){
	int t,opt,x; read(t);
	while (t--){
		read(opt); read(x);
		switch (opt){
			case 1:
				insect(x);
			break;
			case 2:
				deletr(x);
			break;
			case 3:
				query(x);
			break;
			case 4:
				queryk(x);
			break;
			case 5:
				printf("%d\n",pre(ROOT,x));
			break;
			case 6:
				printf("%d\n",pro(ROOT,x));
			break;
		}
	}return 0;
}

指针版的内存池，补上：

#include<cctype>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define for1(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef long long ll;
struct node{
    node *ch[2],*fa;
    int d,size,sum;
    short pl(){return this==fa->ch[1];}
    void count(){sum=ch[0]->sum+ch[1]->sum+size;}
}*null;
int getint(){char c;int fh=1;while(!isdigit(c=getchar()))if(c=='-')fh=-1;int a=c-'0';while(isdigit(c=getchar()))a=a*10+c-'0';return a*fh;}
namespace Splay{
    node *ROOT,pool[100003];
    int tot=0;
    node *newnode(){
    	node *t=&pool[tot++];
    	t->ch[0]=t->ch[1]=t->fa=null;
    	t->size=t->sum=0;
    	return t;
    }
	void Build(){
        null=newnode();
        null->ch[0]=null->ch[1]=null->fa=null;
        ROOT=null;
    }
    void rotate(node *k){
        node *r=k->fa; if (k==null||r==null) return;
        int x=k->pl()^1;
        r->ch[x^1]=k->ch[x];
        r->ch[x^1]->fa=r;
        if (r->fa!=null) r->fa->ch[r->pl()]=k;
        else ROOT=k;
        k->fa=r->fa; r->fa=k;
        k->ch[x]=r;
        r->count(); k->count();
    }
    void splay(node *r,node *tar=null){
        for (;r->fa!=tar;rotate(r))
         if (r->fa->fa!=tar) rotate(r->pl()==r->fa->pl()?r->fa:r);
    }
    void updata(node *r){
        while (r!=null){
            r->count();
            r=r->fa;
        }
    }
    void insert(int x){
        node *r=ROOT;
        if (ROOT==null){
            ROOT=newnode();
            ROOT->d=x;
            ROOT->size=1;
            ROOT->sum=1;
            return;
        }
        while (1){
            int c;
            if (x<r->d) c=0;
            else if (x>r->d) c=1;
            else {r->size++;r->sum++;splay(r); return;}
            if (r->ch[c]==null){
                r->ch[c]=newnode();
                r->ch[c]->fa=r;
                r->ch[c]->d=x;
                r->ch[c]->size=1;
                r->ch[c]->sum=1;
                splay(r->ch[c]);
                return;
            }else r=r->ch[c];
        }
    }
    node *kth(int k){
        node *r=ROOT;
        while (r!=null){
            if (r->ch[0]->sum>=k) r=r->ch[0];
            else if (r->ch[0]->sum+r->size>=k) return r;
            else k-=r->ch[0]->sum+r->size,r=r->ch[1];
        }
        return null;
    }
    node *ques(int k){
        node *r=ROOT; int ans=0;
        while (r!=null){
            if (k<r->d) r=r->ch[0];
            else if (k>r->d) ans+=r->ch[0]->sum+r->size,r=r->ch[1];
            else {printf("%d\n",ans+r->ch[0]->sum+1); return r;}
        }
        return null;
    }
    node *ques2(int k){
        node *r=ROOT;
        while (r!=null){
            if (k<r->d) r=r->ch[0];
            else if (k>r->d) r=r->ch[1];
            else return r;
        }
        return null;
    }
    node *rightdown(node *r){
        while (r->ch[1]!=null){
            r=r->ch[1];
        }return r;
    }
    node *leftdown(node *r){
        while (r->ch[0]!=null){
            r=r->ch[0];
        }return r;
    }
    void deleter(node *r){
        if (r->size>1){
            splay(r);
            r->size--; r->sum--; return;
        }else{
            splay(r);
            if ((r->ch[0]==null)&&(r->ch[1]==null)){
                ROOT=null;
            }else if (r->ch[0]==null){
                r->ch[1]->fa=null;
                ROOT=r->ch[1];
            }else if (r->ch[1]==null){
                r->ch[0]->fa=null;
                ROOT=r->ch[0];
            }else{
                splay(rightdown(r->ch[0]),ROOT);
                r->ch[0]->ch[1]=r->ch[1];
                r->ch[1]->fa=r->ch[0];
                r->ch[0]->fa=null;
                r->ch[0]->count();
                ROOT=r->ch[0];
            }
        }
    }
    int predd(node *r,int x){
        if (r==null) return -1E7-10;
        if (x<=r->d) return predd(r->ch[0],x);
        return max(r->d,predd(r->ch[1],x));
    }
    int pross(node *r,int x){
        if (r==null) return 1E7+10;
        if (r->d<=x) return pross(r->ch[1],x);
        return min(r->d,pross(r->ch[0],x));
    }
    int predds(int x){
        return predd(ROOT,x);
    }
    int prosss(int x){
        return pross(ROOT,x);
    }
}
int main()
{
    int n,x,num;
    n=getint();
    Splay::Build();
    while (n>0){n--;
        x=getint();
        switch(x){
            node *r;
            case 1:
                num=getint();
                Splay::insert(num);
            break;
            case 2:
                num=getint();
                r=Splay::ques2(num);
                Splay::deleter(r);
            break;
            case 3:
                num=getint();
                r=Splay::ques(num);
            break;
            case 4:
                num=getint();
                r=Splay::kth(num);
                printf("%d\n",r->d);
            break;
            case 5:
                num=getint();
                printf("%d\n",Splay::predds(num));
            break;
            case 6:
                num=getint();
                printf("%d\n",Splay::prosss(num));
            break;
        }
    }
    return 0;
}

差不多了

转载于:https://www.cnblogs.com/abclzr/p/5248384.html

as2886089
关注
SDOI2014 Round1 day2
退役狗的专栏
04-13 3610
早上又是早早的起了，还是很紧张
Treap和Splay学习小结
Occult
02-25 4514
最近真的是花了很大的力气来学习平衡树的内容，因为之前在弄偏序的时候提到了平衡树的内容，真的是开了一个大坑啊。 先说说treap吧，网上的资料很多，描述的也很详细，我就不细说了，这里简单的谈谈我的看法，treap就是在二叉树的基础上加了一个随机域来保证堆的性质 这样可以把树的高度维护到期望的logn级别，其他的就是一棵二叉排序树，并没有什么特别的。 我实现了指针版和数组版两种，但是说实话，在写
【BZOJ 3188】【Coci 2011】Upit Splay模板题
as2886089的博客
02-03 123
转啊转终于转出来了，然而我的模板跟陈竞潇学长的模板一模一样，还是太弱啊，第一次用指针。 #include<cstdio> #include<cstring> #include<algorithm> #define for1(i,a,b) for(int i=(a);i<=(b);++i) using namespace std; ...
Splay小结
weixin_43907094的博客
12-02 131
Splay跟fhqTreap一样也是一颗排序二叉树 Splay能够支持区间操作，也使它成为了LCT的辅助树 数据结构 struct pj{ int n, c, f, d, son[2]; //n是该值有多少个，c是子树大小，f是父亲，d是键值，son[0]是左孩子，son[1]是右孩子 } tr[maxn]; 插入一个以f为父亲，键值为d的节点 void add_n(int d, i...
Splay树小结
无限大な梦のあとの 何もない世の中じゃ
08-22 365
http://blog.csdn.net/acm_cxlove/article/details/7815019 附上cxlove大神的博客链接，最近是跟着上面的题目做的。 刚学的时候感觉好难，显示照着大白皮上面敲的模板，然后网上各种看论文，感觉指针写还是太繁琐，还是直接数组写的精炼。感觉Splay树确实强大，可以解决好多序列问题。感觉Splay树的核心是Key_Tree = ch[ch[root
splay 伸展树小结
Brassica_的菜园
01-29 709
其实一开始学习伸展树的时候比较艰难（其实还是自己太菜了QAQ），一个原因是找不到可以入门的水题，还有一个原因是网上其他博客说了很多splay的原理，代码实现却没讲的特别多。然后自己算是小结了一个模板吧，就记在这里 我最开始参考的是cxlove的代码，然后自己改了改，想看他代码的可以直接百度一些splay的题，很多题目第一条结果就是他的博客 splay的原理 英文好的同学可以直接看一下wiki
splay 小结
WDCnew的博客
09-13 388
splay是一种实现比较简单，功能很出色的算法。有人说它是序列之王。 个人感觉splay优秀在容易编写，不管它的应用方法怎么变，打出来的程序都不会有太多变化（就像线段树）。这样只有熟练以后，不过是写的速度还是出错率都会好很多。 这样的功能强劲的方法同时又身兼复杂度优秀。令人啧啧称奇。当然，我说过他很好理解，很好实现。然而“好理解”仅仅指的是算法流程简单，它的时间复杂度不要太多考虑了，我也不明白它为什
[总结] Splay学习小结
Chlience的博客
12-28 354
万分感谢Clove_unique学长给我的启发 变量声明： f[i]表示i的父节点，ch[i][0]表示i的左儿子，ch[i][1]表示i的右儿子，key[i]表示i节点所代表的值，cnt[i]表示key[i]出现的次数（我们将所有值相同的点缩为一个点），size[i]表示i及其子树的大小，sz为整棵树的大小，root为根节点标号 基本性质： 平衡树中的每个节点的左儿子都小于它本身
学习splay或spaly小结
RainbowCrown_CGH's blog
06-27 212
前言 splay是伸展树，是平衡树中的一种。 它主要就是利用神奇的旋转操作来让一颗二叉查找树维护东东。 很早就学过它的旋转，如今早已忘光。 于是接下来就权当新的学习。 我好蔡啊！ 引入 首先我们知道这个二叉查找树是一个十分美妙的树。 但是光有这么一颗树是没有用的。 但是一旦用上splay或spaly，可以维护修改、查询等简单操作。更甚者加入点、删除点、区间翻转这样的高级操作。 而这一切都是从一个叫...
FHQ大战Splay
蒟蒻QMQ
08-15 788
文章目录前言Splay例题学习Splay翻转splay求x的排名求排名为x的数字前驱后继插点删点代码区间操作小结FHQ Treap例题学习FHQ Treap每个点都有些什么分裂合并查询k的排名查询排名为k的数字前驱后继插入删除代码区间操作可持久化FHQ！！！例题学习可持久化分裂合并建链优化具体实现查询排名为x的数前驱后继代码残忍树套树练习12题面题解345（一道贼恶心的区间题）题面题解6题面题解 ...
平衡树(Splay) 服务:第一弹——旋转的艺术
artalter的博客
03-20 800
平衡树(Splay) 服务:第一弹——旋转的艺术 0.前言 本蒟蒻前不久刚学SPLAY，有了一点心得，想要巩固下来。同时也觉得网上的神犇们实在太强了，有的内容并不能很好的让我这样的蒟蒻理解，因此便有了我这篇RBQ级服务的博客。我的splay是看自有风月马前卒学的，因此部分代码可能有些相似。自有风月马前卒是一位高产的神犇，强烈推荐大家看他的博客 1.引入：何为平衡树 平衡树，大家一定都听说过（毕竟没听说过也不会来找Splay博客），那么，平衡树到底是怎么回事呢？就让小编一起带大家来看看吧 平衡树是一种 二叉搜
AVL、Splay和性能分析（伪）
__hao__的博客
12-23 1327
先说明一下，这个玩意是学校数据结构课的作业。完全是赶着ddl写完的，所以后面我都有点不知道自己在写什么。gprof也不太会，瞎弄的。主要放这里做个归档，如果对大家有帮助就更好了。当然，有问题也欢迎大家批评指正。 平衡二叉搜索树性能分析 问题描述 在AVL、Splay和红黑树三种平衡二叉搜索树中至少实现两种，需要支持以下操作：元素插入、删除和查询。在题目中，所有数据均为非负整数。查询时给出一非负整数xxx，需要求出树中满足y≤xy\le xy≤x的最大整数yyy；若树中不存在满足条件的yyy，查询返回-1.
Splay Tree伸展树
Shine__Wong的博客
10-24 450
伸展树基本概念 伸展树的基本思想。 伸展树完全是基于局部性原理(locality)的。 局部性原理是计算机科学中非常重要的原理，很多设计，比如说多级存储器，缓存，都是基于局部性原理。简单说来就是<刚访问过的数据，在一段时间内极有可能再次被访问>。因此，对于物理存储器而言，会将刚刚访问过的数据，转移存储到更高级的存储介质中，比如内存或者缓存，以便下次访问这些数据时可以高效地进行。而对...
用于项目样式reset的资源
11-03
用于项目样式reset的资源
pytz-2016.10.tar.bz2
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-判断键盘按下的键值.zip
11-03
VB程序实例-判断键盘按下的键值.zip
VB程序实例-控制其他程序成为自己的子窗体.zip
11-03
VB程序实例-控制其他程序成为自己的子窗体.zip
VB程序实例85_控件应用_输入序列号.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
springboot032-大学生就业信息管理系统.zip
11-03
项目资源包含：可运行源码+sql文件 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 项目具有较高的学习借鉴价值，也可拿来修改、二次开发。 有任何使用上的问题，欢迎随时与博主沟通，博主看到后会第一时间及时解答。 开发语言：Java 框架：springboot 技术：Vue JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 系统是一个很好的项目，结合了后端服务（SpringBoot）和前端用户界面（Vue.js）技术，实现了前后端分离。 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/index.html
详解优化版C源代码：Top-Down Splay Tree
本文档提供了Splay Tree的一种优化版本的C源代码，专注于Top-Down Splay Trees。Splay Tree是一种自适应二叉搜索树（Adaptive Binary Search Tree），它通过对节点进行旋转操作来保持最近访问的元素在树的根部，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值