P3369 【模板】普通平衡树 avl树数组版

P3369 【模板】普通平衡树

方法一：

//avl数组版 
#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct avlnode{
	int val;
	int size;
	int cnt;
	int height;
	int ls;
	int rs;
}avl[maxn];
int root,tot;
int height(int rt)
{
	return avl[rt].height;
}
void pushup(int rt)
{
	avl[rt].size=avl[avl[rt].ls].size+avl[avl[rt].rs].size+avl[rt].cnt;
}
void LeftRotation(int &rt)
{
	int k;
	k=avl[rt].rs;
	avl[rt].rs=avl[k].ls;
	avl[k].ls=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
void RightRotation(int &rt)
{
	int k;
	k=avl[rt].ls;
	avl[rt].ls=avl[k].rs;
	avl[k].rs=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
int Newavl(int v)
{
	tot++;
	avl[tot].val=v;
	avl[tot].ls=avl[tot].rs=0;
	avl[tot].cnt=avl[tot].size=1;
	avl[tot].height=0;
	return tot;	
}
void preorder(int rt)
{
	if (rt!=0)
	{
		cout<<rt<<",ls"<<avl[rt].ls<<",rs"<<avl[rt].rs<<",cnt"<<avl[rt].cnt<<",size"<<avl[rt].size<<",height"<<avl[rt].height<<",val"<<avl[rt].val<<endl;
		preorder(avl[rt].ls);
		preorder(avl[rt].rs);		
	}
}
void inorder(int rt)
{
	if (rt!=0)
	{
		inorder(avl[rt].ls);
		for (int i=1;i<=avl[rt].cnt;++i) cout<<avl[rt].val<<" "; 
		inorder(avl[rt].rs);
	}
}
void insert(int &rt,int v)
{
	if (rt==0)
	{
		rt=Newavl(v); 
	}
	else if (avl[rt].val>v)
	{
		insert(avl[rt].ls,v);
		if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==2)
		{
			int& k=avl[rt].ls;
			if (avl[avl[k].ls].height>avl[avl[k].rs].height)
			{
				RightRotation(rt);	
			}
			else
			{
				LeftRotation(k);
				RightRotation(rt);
			} 
		}
	}
	else
	{
		insert(avl[rt].rs,v);
		if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==-2)
		{
			int& k=avl[rt].rs;
			if (avl[avl[k].ls].height<avl[avl[k].rs].height)
			{
				LeftRotation(rt);	
			}
			else
			{
				RightRotation(k);
				LeftRotation(rt);
			} 
		}
	}
	pushup(rt);
	avl[rt].height=max(avl[avl[rt].ls].height,avl[avl[rt].rs].height)+1;
}
int Maximum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].rs!=0)
	{
		rt=avl[rt].rs;
	}
	return rt;
}
int Minimum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].ls!=0)
	{
		rt=avl[rt].ls;
	}
	return rt;
}
void dele(int &rt,int v)
{
	if (rt==0) 
	{
		return ;
	}
	if (v<avl[rt].val)
	{
		dele(avl[rt].ls,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==-2)
		{
			int &k=avl[rt].rs;
			if (height(avl[k].ls)>height(avl[k].rs))
			{
				RightRotation(k);
				LeftRotation(rt);
			}
			else
			{
				LeftRotation(rt);		
			}
		}
	}
	else if(v>avl[rt].val)
	{
		dele(avl[rt].rs,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==2)
		{
			int &k=avl[rt].ls;
			if (height(avl[k].rs)>height(avl[k].ls))
			{
				LeftRotation(k);
				RightRotation(rt);
			}
			else
			{
				RightRotation(rt);
			}
		}
	}
	else
	{
		if (avl[rt].ls&&avl[rt].rs)
		{
			if (height(avl[rt].ls)>height(avl[rt].rs))
			{
				int k=Maximum(avl[rt].ls);
				avl[rt].val=avl[k].val;
				dele(avl[rt].ls,avl[k].val);
			}
			else
			{
				int k=Minimum(avl[rt].rs);
				avl[rt].val=avl[k].val;
				dele(avl[rt].rs,avl[k].val);
			}
		}
		else
		{
			rt=avl[rt].ls+avl[rt].rs;
		}
	}
	pushup(rt);
}
int kth(int rt,int k)
{
	if (avl[avl[rt].ls].size+avl[rt].cnt==k) return avl[rt].val;
	else if(k<=avl[avl[rt].ls].size) return kth(avl[rt].ls,k);
	else return kth(avl[rt].rs,k-avl[avl[rt].ls].size-avl[rt].cnt);
}
int Rank(int rt,int val)
{
	if (rt==0) return 1;
	if (avl[rt].val>=val) return Rank(avl[rt].ls,val);
	else return avl[avl[rt].ls].size+avl[rt].cnt+Rank(avl[rt].rs,val);
}
int Pre(int rt,int val)
{
	return kth(rt,Rank(rt,val)-1);
}
int suc(int rt,int val)
{
	return kth(rt,Rank(rt,val+1));
}
int main()
{
	int n;
	cin>>n;
	for (int i=1;i<=n;++i)
	{
		int opt,v;
		cin>>opt;
		if (opt==1)
		{
			cin>>v;
			insert(root,v);	
		}
		else if(opt==2)
		{
			cin>>v;
			dele(root,v);
		}
		else if(opt==3)
		{
			cin>>v;
			cout<<Rank(root,v)<<endl;
		}
		else if (opt==4)
		{
			cin>>v;
			cout<<kth(root,v)<<endl;
		}
		else if(opt==5)
		{
			cin>>v;
			cout<<Pre(root,v)<<endl;
		}
		else if(opt==6)
		{
			cin>>v;
			cout<<suc(root,v)<<endl;
		}
		else if(opt==7)
		{
			inorder(root);
			cout<<endl;
		}
		else if(opt==8)
		{
			preorder(root);
		}
		
	}
	/*
	inorder(root);
	cout<<endl;
	preorder(root);
	*/
}

方法二：

//avl 数组版，合并相同关键字
#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct avlnode{
	int val;
	int size;
	int cnt;
	int height;
	int ls;
	int rs;
}avl[maxn];
int root,tot;
int height(int rt)
{
	if (rt==0) return 0;
	return avl[rt].height;
}
void pushup(int rt)
{
	if (rt==0) return ;
	avl[rt].size=avl[avl[rt].ls].size+avl[avl[rt].rs].size+avl[rt].cnt;
}
void LeftRotation(int &rt)
{
	int k;
	k=avl[rt].rs;
	avl[rt].rs=avl[k].ls;
	avl[k].ls=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
void RightRotation(int &rt)
{
	int k;
	k=avl[rt].ls;
	avl[rt].ls=avl[k].rs;
	avl[k].rs=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
int Newavl(int v)
{
	tot++;
	avl[tot].val=v;
	avl[tot].ls=avl[tot].rs=0;
	avl[tot].cnt=avl[tot].size=1;
	avl[tot].height=0;
	return tot;	
}
void preorder(int rt)
{
	if (rt!=0)
	{
		cout<<rt<<",ls"<<avl[rt].ls<<",rs"<<avl[rt].rs<<",cnt"<<avl[rt].cnt<<",size"<<avl[rt].size<<",height"<<avl[rt].height<<",val"<<avl[rt].val<<endl;
		preorder(avl[rt].ls);
		preorder(avl[rt].rs);		
	}
}
void inorder(int rt)
{
	if (rt!=0)
	{
		inorder(avl[rt].ls);
		for (int i=1;i<=avl[rt].cnt;++i) cout<<avl[rt].val<<" "; 
		inorder(avl[rt].rs);
	}
}
void insert(int &rt,int v)
{
	if (rt==0)
	{
		rt=Newavl(v); 
	}
	else
	{
		if (avl[rt].val>v)
		{
			insert(avl[rt].ls,v);
			if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==2)
			{
				int& k=avl[rt].ls;
				if (avl[avl[k].ls].height>avl[avl[k].rs].height)
				{
					RightRotation(rt);	
				}
				else
				{
					LeftRotation(k);
					//LeftRotation(avl[rt].ls);//LeftRotation(k);??? 
					RightRotation(rt);
				} 
			}
		}
		else if (v>avl[rt].val) 
		{
			insert(avl[rt].rs,v);
			if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==-2)
			{
				int& k=avl[rt].rs;
				if (avl[avl[k].ls].height<avl[avl[k].rs].height)
				{
					LeftRotation(rt);	
				}
				else
				{
					RightRotation(k);
					//RightRotation(avl[rt].rs);//RightRotation(k)  ?? 
					LeftRotation(rt);
				} 
			}
		}
		else
		{
			avl[rt].cnt++;
		}
	}
	pushup(rt);
	avl[rt].height=max(avl[avl[rt].ls].height,avl[avl[rt].rs].height)+1;
}
int Maximum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].rs!=0)
	{
		rt=avl[rt].rs;
	}
	return rt;
}
int Minimum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].ls!=0)
	{
		rt=avl[rt].ls;
	}
	return rt;
}
void dele(int &rt,int v)
{
	if (rt==0) 
	{
		return ;
	}
	if (v<avl[rt].val)
	{
		dele(avl[rt].ls,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==-2)
		{
			int &k=avl[rt].rs;
			if (height(avl[k].ls)>height(avl[k].rs))
			{
				RightRotation(k);
				LeftRotation(rt);
			}
			else
			{
				LeftRotation(rt);		
			}
		}
	}
	else if(v>avl[rt].val)
	{
		dele(avl[rt].rs,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==2)
		{
			int &k=avl[rt].ls;
			if (height(avl[k].rs)>height(avl[k].ls))
			{
				LeftRotation(k);
				RightRotation(rt);
			}
			else
			{
				RightRotation(rt);
			}
		}
	}
	else
	{
		if (avl[rt].ls&&avl[rt].rs)
		{
			if (height(avl[rt].ls)>height(avl[rt].rs))
			{
				int k=Maximum(avl[rt].ls);
				avl[rt].val=avl[k].val;
				avl[rt].cnt=avl[k].cnt;
				dele(avl[rt].ls,avl[k].val);
			}
			else
			{
				int k=Minimum(avl[rt].rs);
				avl[rt].val=avl[k].val;
				avl[rt].cnt=avl[k].cnt;
				dele(avl[rt].rs,avl[k].val);
			}
		}
		else
		{
			rt=avl[rt].ls+avl[rt].rs;
		}
	}
	pushup(rt);
}
void del(int &rt,int v)
{
	if (rt==0)
	{
		return ;
	}
	else if(avl[rt].val==v)
	{
		avl[rt].size--;
		avl[rt].cnt--;
		if (avl[rt].cnt==0)
		{
			dele(rt,v);
		}
	}
	else if(v<avl[rt].val)
	{
		del(avl[rt].ls,v);
	}
	else
	{
		del(avl[rt].rs,v);
	}
	if (rt!=0)
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
}
int kth(int rt,int k)
{
	while(rt!=0)
	{
		if (avl[avl[rt].ls].size<k&&k<=avl[avl[rt].ls].size+avl[rt].cnt)
		{
			return avl[rt].val;	
		}	
		else if(avl[avl[rt].ls].size>=k)
		{
			rt=avl[rt].ls;
		}
		else
		{
			k=k-avl[avl[rt].ls].size-avl[rt].cnt;
			rt=avl[rt].rs;
		}
	} 
}
int Rank(int rt,int val)
{
	int ans=0;
	while(rt!=0)
	{
		if (avl[rt].val==val) return ans+avl[avl[rt].ls].size+1;
		if (avl[rt].val>val) rt=avl[rt].ls;
		else
		{
			ans+=avl[avl[rt].ls].size+avl[rt].cnt;
			rt=avl[rt].rs;
		}
	}
	return ans+1; 
}
int Pre(int rt,int val)
{
	int ans=0x80000000;
	while(rt!=0)
	{
		if (val<=avl[rt].val) rt=avl[rt].ls;
		else
		{
			ans=avl[rt].val;
			rt=avl[rt].rs;
		}
	}
	return ans;
}
int suc(int rt,int val)
{
	int ans=0x7fffffff;
	while(rt!=0)
	{
		if (val>=avl[rt].val) rt=avl[rt].rs;
		else
		{
			ans=avl[rt].val;
			rt=avl[rt].ls;
		}
	}
	return ans;
}
int main()
{
	int n;
	cin>>n;
	for (int i=1;i<=n;++i)
	{
		int opt,v;
		cin>>opt;
		if (opt==1)
		{
			cin>>v;
			insert(root,v);
		}
		else if(opt==2)
		{
			cin>>v;
			del(root,v);
		}
		else if(opt==3)
		{
			cin>>v;
			cout<<Rank(root,v)<<endl;
		}
		else if (opt==4)
		{
			cin>>v;
			cout<<kth(root,v)<<endl;
		}
		else if(opt==5)
		{
			cin>>v;
			cout<<Pre(root,v)<<endl;
		}
		else if(opt==6)
		{
			cin>>v;
			cout<<suc(root,v)<<endl;
		}
		else if(opt==7)
		{
			inorder(root);
			cout<<endl;
		}
		else if(opt==8)
		{
			preorder(root);
		}
		
	}
	/*
	inorder(root);
	cout<<endl;
	preorder(root);
	*/
}

方法三：

//avl MLE
#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct avlnode{
	int val;
	int size;
	int cnt;
	int height;
	int ls;
	int rs;
}avl[maxn];
int root,tot;
int height(int rt)
{
	if (rt==0) return 0;
	return avl[rt].height;
}
void pushup(int rt)
{
	if (rt==0) return ;
	avl[rt].size=avl[avl[rt].ls].size+avl[avl[rt].rs].size+avl[rt].cnt;
}
void LeftRotation(int &rt)
{
	int k;
	k=avl[rt].rs;
	avl[rt].rs=avl[k].ls;
	avl[k].ls=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
void RightRotation(int &rt)
{
	int k;
	k=avl[rt].ls;
	avl[rt].ls=avl[k].rs;
	avl[k].rs=rt;
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
	avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
	pushup(k);
	rt=k;
}
int Newavl(int v)
{
	tot++;
	avl[tot].val=v;
	avl[tot].ls=avl[tot].rs=0;
	avl[tot].cnt=avl[tot].size=1;
	avl[tot].height=0;
	return tot;	
}
void preorder(int rt)
{
	if (rt!=0)
	{
		cout<<rt<<",ls"<<avl[rt].ls<<",rs"<<avl[rt].rs<<",cnt"<<avl[rt].cnt<<",size"<<avl[rt].size<<",height"<<avl[rt].height<<",val"<<avl[rt].val<<endl;
		preorder(avl[rt].ls);
		preorder(avl[rt].rs);		
	}
}
void inorder(int rt)
{
	if (rt!=0)
	{
		inorder(avl[rt].ls);
		for (int i=1;i<=avl[rt].cnt;++i) cout<<avl[rt].val<<" "; 
		inorder(avl[rt].rs);
	}
}
void insert(int &rt,int v)
{
	if (rt==0)
	{
		rt=Newavl(v); 
	}
	else
	{
		if (avl[rt].val>v)
		{
			insert(avl[rt].ls,v);
			if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==2)
			{
				int& k=avl[rt].ls;
				if (avl[avl[k].ls].height>avl[avl[k].rs].height)
				{
					RightRotation(rt);	
				}
				else
				{
					LeftRotation(k);
					//LeftRotation(avl[rt].ls);//LeftRotation(k);??? 
					RightRotation(rt);
				} 
			}
		}
		else if (v>avl[rt].val) 
		{
			insert(avl[rt].rs,v);
			if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==-2)
			{
				int& k=avl[rt].rs;
				if (avl[avl[k].ls].height<avl[avl[k].rs].height)
				{
					LeftRotation(rt);	
				}
				else
				{
					RightRotation(k);
					//RightRotation(avl[rt].rs);//RightRotation(k)  ?? 
					LeftRotation(rt);
				} 
			}
		}
		else
		{
			avl[rt].cnt++;
		}
	}
	pushup(rt);
	avl[rt].height=max(avl[avl[rt].ls].height,avl[avl[rt].rs].height)+1;
}
int Maximum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].rs!=0)
	{
		rt=avl[rt].rs;
	}
	return rt;
}
int Minimum(int rt)
{
	if (rt==0)
	{
		return rt;
	}
	while(avl[rt].ls!=0)
	{
		rt=avl[rt].ls;
	}
	return rt;
}
void dele(int &rt,int v)
{
	if (rt==0) 
	{
		return ;
	}
	if (v<avl[rt].val)
	{
		dele(avl[rt].ls,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==-2)
		{
			int &k=avl[rt].rs;
			if (height(avl[k].ls)>height(avl[k].rs))
			{
				RightRotation(k);
				LeftRotation(rt);
			}
			else
			{
				LeftRotation(rt);		
			}
		}
	}
	else if(v>avl[rt].val)
	{
		dele(avl[rt].rs,v);
		avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
		if (height(avl[rt].ls)-height(avl[rt].rs)==2)
		{
			int &k=avl[rt].ls;
			if (height(avl[k].rs)>height(avl[k].ls))
			{
				LeftRotation(k);
				RightRotation(rt);
			}
			else
			{
				RightRotation(rt);
			}
		}
	}
	else
	{
		if (avl[rt].ls&&avl[rt].rs)
		{
			if (height(avl[rt].ls)>height(avl[rt].rs))
			{
				int k=Maximum(avl[rt].ls);
				avl[rt].val=avl[k].val;
				avl[rt].cnt=avl[k].cnt;
				dele(avl[rt].ls,avl[k].val);
			}
			else
			{
				int k=Minimum(avl[rt].rs);
				avl[rt].val=avl[k].val;
				avl[rt].cnt=avl[k].cnt;
				dele(avl[rt].rs,avl[k].val);
			}
		}
		else
		{
			rt=avl[rt].ls+avl[rt].rs;
		}
	}
	pushup(rt);
}
void del(int &rt,int v)
{
	if (rt==0)
	{
		return ;
	}
	else if(avl[rt].val==v)
	{
		avl[rt].size--;
		avl[rt].cnt--;
		if (avl[rt].cnt==0)
		{
			dele(rt,v);
		}
	}
	else if(v<avl[rt].val)
	{
		del(avl[rt].ls,v);
	}
	else
	{
		del(avl[rt].rs,v);
	}
	if (rt!=0)
	avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
	pushup(rt);
}
int kth(int rt,int k)
{
	if(avl[avl[rt].ls].size>=k) return kth(avl[rt].ls,k);
	else if(avl[avl[rt].ls].size+avl[rt].cnt>=k) return avl[rt].val;
	else return kth(avl[rt].rs,k-avl[avl[rt].ls].size-avl[rt].cnt);
}
int Rank(int rt,int val)
{
	int ans=0;
	while(rt!=0)
	{
		if (avl[rt].val==val) return ans+avl[avl[rt].ls].size+1;
		if (avl[rt].val>val) rt=avl[rt].ls;
		else
		{
			ans+=avl[avl[rt].ls].size+avl[rt].cnt;
			rt=avl[rt].rs;
		}
	}
	return ans+1; 
}
int Pre(int rt,int val)
{
	int ans=0x80000000;
	while(rt!=0)
	{
		if (val<=avl[rt].val) rt=avl[rt].ls;
		else
		{
			ans=avl[rt].val;
			rt=avl[rt].rs;
		}
	}
	return ans;
}
int suc(int rt,int val)
{
	int ans=0x7fffffff;
	while(rt!=0)
	{
		if (val>=avl[rt].val) rt=avl[rt].rs;
		else
		{
			ans=avl[rt].val;
			rt=avl[rt].ls;
		}
	}
	return ans;
}
int main()
{
	int n;
	cin>>n;
	for (int i=1;i<=n;++i)
	{
		int opt,v;
		cin>>opt;
		if (opt==1)
		{
			cin>>v;
			insert(root,v);
		}
		else if(opt==2)
		{
			cin>>v;
			del(root,v);
		}
		else if(opt==3)
		{
			cin>>v;
			cout<<Rank(root,v)<<endl;
		}
		else if (opt==4)
		{
			cin>>v;
			cout<<kth(root,v)<<endl;
		}
		else if(opt==5)
		{
			cin>>v;
			cout<<Pre(root,v)<<endl;
		}
		else if(opt==6)
		{
			cin>>v;
			cout<<suc(root,v)<<endl;
		}
		else if(opt==7)
		{
			inorder(root);
			cout<<endl;
		}
		else if(opt==8)
		{
			preorder(root);
		}
		
	}
}

方法四：

//avl 数组版，合并相同关键字
#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct avlnode{
    int val;
    int size;
    int cnt;
    int height;
    int ls;
    int rs;
}avl[maxn];
int root,tot;
int height(int rt)
{
    if (rt==0) return 0;
    return avl[rt].height;
}
void pushup(int rt)
{
    if (rt==0) return ;
    avl[rt].size=avl[avl[rt].ls].size+avl[avl[rt].rs].size+avl[rt].cnt;
}
void LeftRotation(int &rt)
{
    int k;
    k=avl[rt].rs;
    avl[rt].rs=avl[k].ls;
    avl[k].ls=rt;
    avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
    pushup(rt);
    avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
    pushup(k);
    rt=k;
}
void RightRotation(int &rt)
{
    int k;
    k=avl[rt].ls;
    avl[rt].ls=avl[k].rs;
    avl[k].rs=rt;
    avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
    pushup(rt);
    avl[k].height=max(height(avl[k].ls),height(avl[k].rs))+1;
    pushup(k);
    rt=k;
}
int Newavl(int v)
{
    tot++;
    avl[tot].val=v;
    avl[tot].ls=avl[tot].rs=0;
    avl[tot].cnt=avl[tot].size=1;
    avl[tot].height=0;
    return tot;
}
void preorder(int rt)
{
    if (rt!=0)
    {
        cout<<rt<<",ls"<<avl[rt].ls<<",rs"<<avl[rt].rs<<",cnt"<<avl[rt].cnt<<",size"<<avl[rt].size<<",height"<<avl[rt].height<<",val"<<avl[rt].val<<endl;
        preorder(avl[rt].ls);
        preorder(avl[rt].rs);      
    }
}
void inorder(int rt)
{
    if (rt!=0)
    {
        inorder(avl[rt].ls);
        for (int i=1;i<=avl[rt].cnt;++i) cout<<avl[rt].val<<" ";
        inorder(avl[rt].rs);
    }
}
void insert(int &rt,int v)
{
    if (rt==0)
    {
        rt=Newavl(v);
    }
    else
    {
        if (avl[rt].val>v)
        {
            insert(avl[rt].ls,v);
            if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==2)
            {
                int& k=avl[rt].ls;
                if (avl[avl[k].ls].height>avl[avl[k].rs].height)
                {
                    RightRotation(rt); 
                }
                else
                {
                    LeftRotation(k);
                    //LeftRotation(avl[rt].ls);//LeftRotation(k);???
                    RightRotation(rt);
                }
            }
        }
        else if (v>avl[rt].val)
        {
            insert(avl[rt].rs,v);
            if (avl[avl[rt].ls].height-avl[avl[rt].rs].height==-2)
            {
                int& k=avl[rt].rs;
                if (avl[avl[k].ls].height<avl[avl[k].rs].height)
                {
                    LeftRotation(rt);  
                }
                else
                {
                    RightRotation(k);
                    //RightRotation(avl[rt].rs);//RightRotation(k)  ??
                    LeftRotation(rt);
                }
            }
        }
        else
        {
            avl[rt].cnt++;
        }
    }
    pushup(rt);
    avl[rt].height=max(avl[avl[rt].ls].height,avl[avl[rt].rs].height)+1;
}
int Maximum(int rt)
{
    if (rt==0)
    {
        return rt;
    }
    while(avl[rt].rs!=0)
    {
        rt=avl[rt].rs;
    }
    return rt;
}
int Minimum(int rt)
{
    if (rt==0)
    {
        return rt;
    }
    while(avl[rt].ls!=0)
    {
        rt=avl[rt].ls;
    }
    return rt;
}
void dele(int &rt,int v)
{
    if (rt==0)
    {
        return ;
    }
    if (v<avl[rt].val)
    {
        dele(avl[rt].ls,v);
        avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
        if (height(avl[rt].ls)-height(avl[rt].rs)==-2)
        {
            int &k=avl[rt].rs;
            if (height(avl[k].ls)>height(avl[k].rs))
            {
                RightRotation(k);
                LeftRotation(rt);
            }
            else
            {
                LeftRotation(rt);      
            }
        }
    }
    else if(v>avl[rt].val)
    {
        dele(avl[rt].rs,v);
        avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
        if (height(avl[rt].ls)-height(avl[rt].rs)==2)
        {
            int &k=avl[rt].ls;
            if (height(avl[k].rs)>height(avl[k].ls))
            {
                LeftRotation(k);
                RightRotation(rt);
            }
            else
            {
                RightRotation(rt);
            }
        }
    }
    else
    {
        if (avl[rt].ls&&avl[rt].rs)
        {
            if (height(avl[rt].ls)>height(avl[rt].rs))
            {
                int k=Maximum(avl[rt].ls);
                avl[rt].val=avl[k].val;
                avl[rt].cnt=avl[k].cnt;
                dele(avl[rt].ls,avl[k].val);
            }
            else
            {
                int k=Minimum(avl[rt].rs);
                avl[rt].val=avl[k].val;
                avl[rt].cnt=avl[k].cnt;
                dele(avl[rt].rs,avl[k].val);
            }
        }
        else
        {
            rt=avl[rt].ls+avl[rt].rs;
        }
    }
    pushup(rt);
}
void del(int &rt,int v)
{
    if (rt==0)
    {
        return ;
    }
    else if(avl[rt].val==v)
    {
        avl[rt].size--;
        avl[rt].cnt--;
        if (avl[rt].cnt==0)
        {
            dele(rt,v);
        }
    }
    else if(v<avl[rt].val)
    {
        del(avl[rt].ls,v);
    }
    else
    {
        del(avl[rt].rs,v);
    }
    if (rt!=0)
    avl[rt].height=max(height(avl[rt].ls),height(avl[rt].rs))+1;
    pushup(rt);
}
int kth(int rt,int k)
{
    if (avl[avl[rt].ls].size>=k) return kth(avl[rt].ls,k);
    else if(avl[avl[rt].ls].size+avl[rt].cnt>=k) return avl[rt].val;
    else return kth(avl[rt].rs,k-avl[avl[rt].ls].size-avl[rt].cnt);
}
int Rank(int rt,int val)
{
    if (rt==0) return 1;
    if (avl[rt].val>=val) return Rank(avl[rt].ls,val);
    else return avl[avl[rt].ls].size+avl[rt].cnt+Rank(avl[rt].rs,val);
}
int Pre(int rt,int val)
{
    return kth(rt,Rank(rt,val)-1);
}
int suc(int rt,int val)
{
    return kth(rt,Rank(rt,val+1));
}
int main()
{
    int n;
    
    cin>>n;
    for (int i=1;i<=n;++i)
    {
        int opt,v;
        cin>>opt;
        if (opt==1)
        {
            cin>>v;
            insert(root,v);
        }
        else if(opt==2)
        {
            cin>>v;
            del(root,v);
        }
        else if(opt==3)
        {
            cin>>v;
            cout<<Rank(root,v)<<endl;
        }
        else if (opt==4)
        {
            cin>>v;
            cout<<kth(root,v)<<endl;
        }
        else if(opt==5)
        {
            cin>>v;
            cout<<Pre(root,v)<<endl;
        }
        else if(opt==6)
        {
            cin>>v;
            cout<<suc(root,v)<<endl;
        }
        else if(opt==7)
        {
            inorder(root);
            cout<<endl;
        }
        else if(opt==8)
        {
            preorder(root);
        }
         
    }
  
}