【详解】二叉查找树BST与平衡树Treap

最新推荐文章于 2022-02-14 01:32:12 发布
最新推荐文章于 2022-02-14 01:32:12 发布
阅读量841 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/STRVE/article/details/106314562
版权

目录

二叉查找树BST与平衡树Treap

一、二叉查找树BST

二叉查找树（简称BST），是满足以下条件的二叉树：

  1. 树上每一个节点都有一个权值；
  2. 对于树上任意一个节点u，若左子树不为空，则左子树上所有节点权值均小于u的权值；
  3. 对于树上任意一个节点u，若右子树不为空，则右子树上所有节点权值均大于u的权值；
    如下图：
    在这里插入图片描述

1. 二叉查找树的建立

struct BST		
{
    int l,r;	//左右子节点的编号
    int val;	//节点权值
}s[SIZE];		//数组模拟链表
int tot,root=1;	//tot记录当前节点数目，root为根节点
int INF=0x7fffffff;		//int的最大值

//主函数main()中
a[++tot].val=INF;	//添加一个无穷大的节点，就不需要判断BST是否为空，方便操作

二叉查找树的中序遍历，就是权值从小到大的排列顺序。

2. 二叉查找树的查找

在BST中查找是否存在权值为x的节点，执行流程如下：
设变量p等于根节点root
(1) 若a[p].val==x，则查找成功。
(2) 若a[p].val>x
① 若p的左子节点为空，查找失败，说明不存在。
② 若p的左子节点不为空，则继续在p的左子树中递归查找。
(3) 若a[p].val<x
① 若p的右子节点为空，查找失败，说明不存在。
② 若p的右子节点不为空，则继续在p的右子树中递归查找。

int Find(int p,int x)	//当前节点为p，查找值为x的节点
{
	if(p==0)	return 0;	//节点为空，查找失败
	if(a[p].val==x)	return p;	//查找成功，返回x的位置
	return a[p].val<x ? Find(a[p].r,x) : Find(a[p].l,x);
}

3. 二叉查找树找最值

以找最小值为例，从根节点root开始，若左子节点不为空，访问左子节点，直到左子节点为空。

int Find_min(int p)
{
	if(p) while(a[p].l)	p=a[p].l;
	return a[p].val;	//返回最小值
}

找最大值方法类似。

4. 二叉查找树插入

BST中插入一个权值x，其实就是在BST中查找权值为x的节点：当权值x的节点存在时，添加一个域，记录重复个数；当权值x的节点不存在时，即找到了空节点，插入到空节点。

void Insert(int &p,int x)		//插入权值x，当前结点为p
{
	if(p==0)
	{
		a[++tot].val=x;			//添加一个新的节点
		p=tot;					//p是引用，其父节点的l或r值会被同时更新，指向节点tot
		return;
	}
	if(x==a[p].val)	return;		//已经存在，不插入，根据题意，也可以记录重复的个数
	return x<a[p].val ? Insert(a[p].l,x) : Insert(a[p].r,x);
}
引用

这里的&表示引用，引用在程序中相当于一个变量的别名，代表的都是同一个变量，只是名称不相同而已(类似每个人都有一个外号、小名等)，对别名进行操作等同于对原变量进行操作，例如：

int a=10;
int &b=a;	//b是a的别名
b+=2;
cout<<a;	//输出答案为12

例如在下图BST中插入权值6：
设插入的权值顺序依次为8、12、15、5、7、10、9、3，对应的节点编号依次为1~8.
在这里插入图片描述
程序执行流程：
(1) 首先调用函数Insert(root,6)，root的别名为p（root为根节点，root=1），接着递归调用函数Insert(a[root].l,6)，
(2)a[root].l的别名为p，a[root].l等于4，即执行函数Insert(4,6)，接着递归调用函数Insert(a[4].r,6)；
(3)a[4].r的别名为p，a[4].r等于5，即执行函数Insert(5,6)，接着递归调用函数Insert(a[5].l,6)；
(4)a[5].l的别名为p，p为空，添加一个新的节点，执行p=tot，相当于a[5].l=tot。
这样，添加一个节点的同时，可以同时更新其父节点的l或r。

5. 二叉查找树的删除

在BST中删除权值为x的节点，需要先查找是否存在。
若查找到权值为x的节点编号为p，需要分三种情况：
(1)p为叶子节点，则直接删除。
(2)p只有一个子节点，则让子节点代替p的位置，(1)的情况也可以按照此方式进行处理，叶节点的子节点就是空节点，空节点代替等同于删除。
(3)p既有左子树也有右子树，则在BST中寻找节点p的后继节点nxt来代替p的位置，后继节点就是大于x且权值最小的节点，后继节点nxt一定不存在左子树，所以可以直接删除后继节点nxt，并令后继节点nxt的右子树代替nxt的位置。
后继节点nxt一定不存在左子树，如果后继节点存在左子树，那么左子树的节点权值大于x，且小于nxt的权值，与nxt是后继节点矛盾。
后继节点的寻找方法:
找到权值为x的节点p时，令nxt=a[p].r，然后一直往节点nxt的左子节点递归往下找，最后一个非空的节点即为后继节点。

void Remove(int &p,int x)		//从子树p中删除权值为x的节点,p是引用，是父结点的l或r的别名
{
	if(p==0)	return;
	if(x==a[p].val)	//查找到x
	{
		if(a[p].l==0)	p=a[p].r;	//无左子树,右子节点代替
		else if(a[p].r==0)	p=a[p].l;	//无右子树，左子节点代替
		else							//既有左子树，又有右子树
		{
			//后继节点往p的右子节点的左子节点一直往下找
			int nxt=a[p].r;		
			while(a[nxt].l)	nxt=a[nxt].l;
			Remove(a[p].r,a[nxt].val);		//删除后继节点nxt
			a[nxt].l=a[p].l;				//nxt代替p的位置
			a[nxt].r=a[p].r;
			p=nxt;							//p是引用，是父结点的l或r的别名,指向添加的节点nxt
		}
		return;
	}
	if(x<a[p].val)	Remove(a[p].l,x);
	else	Remove(a[p].r,x);
}

在随机数据中，BST的每次操作时间复杂度为O(logN)。然而，如果按照权值顺序插入，则BST的形态是一条链。
依次插入权值：3、5、6、8、12、15，BST形态如下：
在这里插入图片描述
时间复杂度会降低到O(N)，为了使得BST的形态“平衡”，每次操作时间复杂度尽可能接近O(logN)，从而产生了平衡树。

样例

二叉查找树
【题目描述】
N个操作，分别对应插入一个数和删除一个数，如果插入的数已存在，输出has been,否则将这个数插入，并输出insert success，对于删除一个数，如果该数不存在，输出not exist，如果存在，删除它，并输出delete success。
【输入】
第一行n(n<=100000)，表示有n个操作数； 之后n行，每行一个字母（I表示插入，D表示删除），一个数字（数字为正整数，整型范围内）。
【输出】
n行，每行按描述的方式输出。
【样例输入】

10
D 1
I 3
I 5
I 3
I 4
D 4
D 5
D 3
I 2
D 1

【样例输出】

not exist
insert success
insert success
has been
insert success
delete success
delete success
delete success
insert success
not exist

【参考程序】

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
struct BST
{
	int l,r;
	int val;
}a[N];
int n,tot,root=1,INF=0x7fffffff;		//INF为int最大值 
int flag=0;								//标记是否删除 
void Insert(int &p,int x)				//插入权值x，当前结点为p
{
	if(p==0)
	{
		a[++tot].val=x;					//添加一个新的节点
		p=tot;							//p是引用，其父节点的l或r值会被同时更新，指向节点tot
		printf("insert success\n");
		return;
	}
	if(x==a[p].val)	{printf("has been\n");return;}		//已经存在，不插入
	return x<a[p].val ? Insert(a[p].l,x) : Insert(a[p].r,x);
}
void Remove(int &p,int x)				//从子树p中删除权值为x的节点,p是引用，是父结点的l或r的别名
{
	if(p==0)	{printf("not exist\n");return;} 	//不存在 
	if(x==a[p].val)						//查找到x
	{
		if(a[p].l==0)		p=a[p].r;	//无左子树,右子节点代替
		else if(a[p].r==0)	p=a[p].l;	//无右子树，左子节点代替
		else							//既有左子树，又有右子树
		{
			//后继节点往p的右子节点的左子节点一直往下找
			int nxt=a[p].r;		
			while(a[nxt].l)	nxt=a[nxt].l;
			Remove(a[p].r,a[nxt].val);		//删除后继节点nxt
			a[nxt].l=a[p].l;				//nxt代替p的位置
			a[nxt].r=a[p].r;
			p=nxt;							//p是引用，是父结点的l或r的别名,指向添加的节点nxt
		}
		flag=1;								//如果删除后继节点，会有两次删除，记录一次 
		return;
	}
	if(x<a[p].val)	Remove(a[p].l,x);
	else	Remove(a[p].r,x);
}
int main()
{
	a[++tot].val=INF;	//添加一个无穷大的节点，就不需要判断BST是否为空，方便操作 
	scanf("%d",&n);
	char ch[5];
	int x;
	for(int i=1;i<=n;i++)
	{
		flag=0;						 
		scanf("%s%d",ch,&x);	
		if(ch[0]=='I')	Insert(root,x);	
		else	Remove(root,x); 
		if(flag)	printf("delete success\n");
	}	
	return 0;
}

二、平衡树Treap

Treap是一种简单的平衡树，在普通二叉查找树的基础上，赋予每个节点一个属性：优先级。
对于Treap中的节点，除了权值满足二叉查找树的性质外，节点的优先级还要满足大根堆(小根堆)的性质。
简单来说，从权值上看，Treap是一棵二叉查找树，从优先级上看，Treap是一个堆(Heap)。所有Treap就是Tree+Heap，单词Treap就是Tree与Heap的合成词。
BST不平衡是因为有序的数据会使查找的路径退化成链，而随机数据使其退化的概率非常小。因此，Treap中每个节点的优先级的值可以通过随机函数生成，这样Treap的结构就会趋于平衡了。

sconst int N=100010;
struct Treap
{
	int l,r;	//左右子节点下标
	int val;	//权值
	int pr;		//优先级
	int cnt;	//重复个数
	int size;	//子树大小
}a[N];
int n,tot,root=1,INF=0x3fffffff;
void Update(int p)		//更新子树大小
{
	a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;	
}

1. Treap旋转

为了使Treap在满足BST的性质的同时，也同时满足大根堆的性质，需要对Treap的结构进行调整，而调整的方法为旋转，旋转分为左旋和右旋，如下图所示：
在这里插入图片描述
注意：

  • 旋转操作是保证在BST性质的基础上，根据节点优先级调整。
  • 旋转不会改变BST的性质，只会改变节点优先级的位置。
    （1）若x的优先级大于y的优先级，如上左图，需要进行右旋：将x变为y的父节点，x原来的右子树变为y的左子树。
void Zig(int &p)	//	右旋，p的左子节点变为p的父节点
{
	int q=a[p].l;	//p的左子节点为q
	a[p].l=a[q].r;	//q的右子树变为p的左子树
	a[q].r=p;		//q变为p的父节点
	p=q;			//引用，p是其父节点的l或r的别名，指向q
	Update(a[p].r);Update(p);	//改变结构后，更新子树大小 
}

（2）若y的优先级大于x的优先级，如上右图，需要进行左旋：将y变为x的父节点，y原来的左子树变为x的右子树。

void Zag(int &p)	//左旋，p的右子节点变为p的父节点
{
	int q=a[p].r;	//p的右子节点为q
	a[p].r=a[q].l;	//q的左子树变为p的右子树
	a[q].l=p;		//q变为p的父节点
	p=q;			//引用，p是其父节点的l或r的别名，指向q
	Update(a[p].l);Update(p); 	//改变结构后，更新子树大小 
}

2. Treap插入

Treap在插入每个新节点时，在有权值属性的基础上，会给该节点生成一个随机值，作为优先级的属性。然后像堆的插入过程一样，自底向上依次检查，当某个节点不满足大根堆性质时，就执行旋转，使该节点与父节点交换。
插入节点的过程，先按照BST性质，即权值大小插入到合适位置；再按照堆的性质，调整优先级，使其满足大根堆性质，步骤如下：
设变量p初始时等于root，插入权值为x的节点：
(1)若x==a[p].val，节点p的数量+1。
(2)若x<a[p].val，递归往p的左子树a[p].l插入。
(3)若x>a[p].val，递归往p的右子树a[p].r插入。
(4)若p为空节点，插入到当前节点，生成一个随机值作为当前节点的优先级。
此时，是满足BST性质的，但是不一定满足大根堆的性质。因此在回溯的时候，若不满足大根堆性质，进行旋转。
(5)若p的左子节点优先级大于p，则进行右旋，交换左子节点与p的位置。
(6)若p的右子节点优先级大于p，则进行左旋，交换右子节点与p的位置。

void Insert(int &p,int x)	//插入 
{	
	if(x==a[p].val)		//存在权值为x的节点
	{
		a[p].cnt++;		//数量+1
		Update(p);
		return;
	}
	if(p==0)				//添加节点
	{
		a[++tot].val=x;			
		a[tot].pr=rand();	//rand()随机函数，优先级为随机值
		a[tot].cnt=1;
		a[tot].size=1;
		p=tot;				//引用，p是其父节点l或r的别名，指向tot
		return;
	}
	if(x<a[p].val)
	{
		Insert(a[p].l,x);					//递归插入
		if(a[p].pr<a[a[p].l].pr)	Zig(p);	//回溯，不满足堆的性质，右旋
	}
	if(x>a[p].val)
	{
		Insert(a[p].r,x);					//递归插入
		if(a[p].pr<a[a[p].r].pr)	Zag(p);//回溯，不满足堆的性质，左旋
	}
	Update(p);					//回溯，更新子树大小
}

3. Treap删除

如果删除的节点为叶节点，可以直接删除。对于非叶子节点，因为Treap支持旋转，可以通过旋转将其变为叶子节点。
（1）若删除的节点p是非叶子节点，选择左右子节点优先级大的和节点p交换：
（2）若左子节点优先级大，则右旋，保证优先级大的左子节点在右子节点上方。
（3）若右子节点优先级大，则左旋，保证优先级大的右子节点在左子节点上方。
如下图，删除节点15：
在这里插入图片描述
首先查找到权值为15的位置，比较左右子节点优先级，左子节点优先级高，右旋：在这里插入图片描述
继续比较左右子节点优先级，右子节点优先级高，左旋：
在这里插入图片描述
继续比较左右子节点优先级，左子节点优先级高，右旋：
在这里插入图片描述
此时，删除的节点为叶子节点，可以直接删除。

void Remove(int &p,int x)			//删除权值x 
{
	if(p==0)	return;		//不存在
	if(x==a[p].val)
	{
		if(a[p].cnt>1)		//有重复元素，减少个数
		{
			a[p].cnt--;		
			Update(p);		//更新子树大小
			return;
		}
		if(a[p].l||a[p].r)	//非叶子节点
		{
			if(a[a[p].l].pr>a[a[p].r].pr)	Zig(p),Remove(a[p].r,x);	//右旋
			else	Zag(p),Remove(a[p].l,x);							//左旋
			a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;	//回溯更新子树大小
		}
		else 				//叶子节点
			p=0;			//引用，p是父节点l或r的别名，指向0，即删除
		return;
	}
	if(x<a[p].val)	Remove(a[p].l,x);
	if(x>a[p].val)	Remove(a[p].r,x);
	Update(p);	//回溯更新子树大小
}

4. 求数值x的前驱与后继

前驱定义为小于x的最大数，后继定义为大于x的最小数。
求解前驱：
设ans为当前最优解，令变量p等于根节点root，从p开始访问：
（1）若当前节点a[p].val<x，且a[p].val>ans，则更新最优解，继续寻找：若a[p].val<x，往右子节点a[p].r找，否则往左子节点a[p].l找。
（2）若a[p].val==x，则先找到p的左子节点，再从左子节点的右子节点一直往下找。
（3）若p为空，则停止寻找。

int Getpre(int x)						//前驱 
{
	int ans=-INF;
	int p=root;
	while(p)
	{
		if(x==a[p].val)					//找到相等
		{
			if(a[p].l)
			{
				p=a[p].l;
				while(a[p].r)	p=a[p].r;
				ans=a[p].val;
			}
			break;
		}
		if(a[p].val<x&&a[p].val>ans)	ans=a[p].val;	//更新最优解
		if(a[p].val<x)	p=a[p].r;						//选择合适的方向继续找
		else p=a[p].l;
	}
	return ans;
}

求解后驱方法类似：

int Getnxt(int x)						//后驱 
{
	int ans=INF;
	int p=root;
	while(p)
	{
		if(x==a[p].val)					//找到相等
		{
			if(a[p].r)
			{
				p=a[p].r;
				while(a[p].l)	p=a[p].l;
				ans=a[p].val;
			}
			break;
		}
		if(a[p].val>x&&a[p].val<ans)	ans=a[p].val;	//更新最优解
		if(a[p].val<x)	p=a[p].r;						//选择合适的方向继续找
		else p=a[p].l;
	}
	return ans;
}

5. 求排名为k的元素

求排名，需要维护每个节点为根的子树大小，即程序中的size属性。
一个节点的排名，取决于其左子树的大小。设当前访问的子树根节点为p，重复元素个数为a[p].cnt，p在作为子树根节点，在子树中的排名介于：左子树节点总数+1 ~ 左子树节点总数+p的重复个数，即区间[ a[ a[p].l ].size + 1 , a[ a[p].l] ].size + a[p].cnt ]之间。因为左子树节点权值都小于p。
（1）若 a[a[p].l].size +1<=k && k<=a[a[p].l]].size + a[p].cnt，则排名k的节点就是当前节点p。
（2）若k <= a[a[p].l].size，则排名k的节点在左子树中。
（3）若k > a[a[p].l]].size + a[p].cnt，则排名k的节点子在右子树中，相当于在右子树中找排名为k-(a[a[p].l]].size + a[p].cnt)的节点。
在插入删除的时候，都需要从下往上更新size，一般采用递归的形式，以便于在回溯的时候更新size。

int GetRank(int p,int k)		//在根节点p的子树中，查找排名为k的元素
{
	if(a[a[p].l].size+1<=k && k<=a[a[p].l].size+a[p].cnt)	return a[p].val;
	if(k<=a[a[p].l].size)	return GetRank(a[p].l,k);
	return GetRank(a[p].r,k-(a[a[p].l].size + a[p].cnt));
}

6. 求元素x的排名

求元素x的排名，类似于查找元素x的位置，在查找的过程中，统计比x小的元素个数。
设当前访问节点为p：
（1）若x==a[p].val，则比x小的元素有a[a[p].l].size个。
（2）若x<a[p].val，则在左子树继续找。
（3）若x>a[p].val，则在右子树继续找，且比x小的元素有a[a[p].l].size+a[p].cnt个。

int Getx_Rank(int p,int x)		//当前访问节点p，查找x的排名
{
	if(p==0)	return 0;
	if(x==a[p].val)	return a[a[p].l].size+1;		//排名+1
	if(x<a[p].val)	return Getx_Rank(a[p].l,x);
	return Getx_Rank(a[p].r,x)+a[a[p].l].size+a[p].cnt;
}

Treap通过旋转，在维持权值满足BST性质之外，还能使节点的优先级满足大根堆的性质。
Treap的树的深度期望是O(logN)，所以各个操作的期望时间复杂度为O(logN)。

样例

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

  1. 插入x数
  2. 删除x数(若有多个相同的数，因只删除一个)
  3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
  4. 查询排名为x的数
  5. 求x的前驱(前驱定义为小于x，且最大的数)
  6. 求x的后继(后继定义为大于x，且最小的数)
    （ps：排名指的是从小到大排，且若有两个数相同则两个数均占名额。执行3操作时，输出排名最靠前的x数的排名）
    【输入】
    第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)
    【输出】
    对于操作3,4,5,6每行输出一个数，表示对应答案
    【样例输入】
10 
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

【样例输出】
106465 84185 492737

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
struct Treap
{
	int l,r;	//左右子节点下标
	int val;	//权值
	int pr;		//优先级
	int cnt;	//重复个数
	int size;	//子树大小
}a[N];
int n,tot,root=1,INF=0x3fffffff;
void Update(int p)		//更新子树大小
{
	a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;	
}
void Zig(int &p)	//	右旋，p的左子节点变为p的父节点
{
	int q=a[p].l;	//p的左子节点为q
	a[p].l=a[q].r;	//q的右子树变为p的左子树
	a[q].r=p;		//q变为p的父节点
	p=q;			//引用，p是其父节点的l或r的别名，指向q
	Update(a[p].r);Update(p);	//改变结构后，更新子树大小 
}
void Zag(int &p)	//左旋，p的右子节点变为p的父节点
{
	int q=a[p].r;	//p的右子节点为q
	a[p].r=a[q].l;	//q的左子树变为p的右子树
	a[q].l=p;		//q变为p的父节点
	p=q;			//引用，p是其父节点的l或r的别名，指向q
	Update(a[p].l);Update(p); 	//改变结构后，更新子树大小 
}
void Insert(int &p,int x)	//插入 
{	
	if(x==a[p].val)		//存在权值为x的节点
	{
		a[p].cnt++;		//数量+1
		Update(p);
		return;
	}
	if(p==0)				//添加节点
	{
		a[++tot].val=x;			
		a[tot].pr=rand();	//rand()随机函数，优先级为随机值
		a[tot].cnt=1;
		a[tot].size=1;
		p=tot;				//引用，p是其父节点l或r的别名，指向tot
		return;
	}
	if(x<a[p].val)
	{
		Insert(a[p].l,x);					//递归插入
		if(a[p].pr<a[a[p].l].pr)	Zig(p);	//回溯，不满足堆的性质，右旋
	}
	if(x>a[p].val)
	{
		Insert(a[p].r,x);					//递归插入
		if(a[p].pr<a[a[p].r].pr)	Zag(p);//回溯，不满足堆的性质，左旋
	}
	Update(p);					//回溯，更新子树大小
}
void Remove(int &p,int x)			//删除权值x 
{
	if(p==0)	return;		//不存在
	if(x==a[p].val)
	{
		if(a[p].cnt>1)		//有重复元素，减少个数
		{
			a[p].cnt--;		
			Update(p);		//更新子树大小
			return;
		}
		if(a[p].l||a[p].r)	//非叶子节点
		{
			if(a[a[p].l].pr>a[a[p].r].pr)	Zig(p),Remove(a[p].r,x);	//右旋
			else	Zag(p),Remove(a[p].l,x);							//左旋
			a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;	//回溯更新子树大小
		}
		else 				//叶子节点
			p=0;			//引用，p是父节点l或r的别名，指向0，即删除
		return;
	}
	if(x<a[p].val)	Remove(a[p].l,x);
	if(x>a[p].val)	Remove(a[p].r,x);
	Update(p);	//回溯更新子树大小
}
int Getpre(int x)						//前驱 
{
	int ans=-INF;
	int p=root;
	while(p)
	{
		if(x==a[p].val)					//找到相等
		{
			if(a[p].l)
			{
				p=a[p].l;
				while(a[p].r)	p=a[p].r;
				ans=a[p].val;
			}
			break;
		}
		if(a[p].val<x&&a[p].val>ans)	ans=a[p].val;	//更新最优解
		if(a[p].val<x)	p=a[p].r;						//选择合适的方向继续找
		else p=a[p].l;
	}
	return ans;
}
int Getnxt(int x)						//后驱 
{
	int ans=INF;
	int p=root;
	while(p)
	{
		if(x==a[p].val)					//找到相等
		{
			if(a[p].r)
			{
				p=a[p].r;
				while(a[p].l)	p=a[p].l;
				ans=a[p].val;
			}
			break;
		}
		if(a[p].val>x&&a[p].val<ans)	ans=a[p].val;	//更新最优解
		if(a[p].val<x)	p=a[p].r;						//选择合适的方向继续找
		else p=a[p].l;
	}
	return ans;
}
int Getx_Rank(int p,int x)		//在根节点p的子树中，查找x的排名
{
	if(p==0)	return 0;
	if(x==a[p].val)	return a[a[p].l].size+1;		//排名+1
	if(x<a[p].val)	return Getx_Rank(a[p].l,x);
	return Getx_Rank(a[p].r,x)+a[a[p].l].size+a[p].cnt;
}
int GetRank(int p,int k)		//在根节点p的子树中，查找排名为k的元素
{
	if(a[a[p].l].size+1<=k && k<=a[a[p].l].size+a[p].cnt)	return a[p].val;
	if(k<=a[a[p].l].size)	return GetRank(a[p].l,k);
	return GetRank(a[p].r,k-(a[a[p].l].size + a[p].cnt));
}
int main()
{	
    a[++tot].val=INF;       //添加一个超级根节点，方便操作 
    a[tot].pr=INF;
    scanf("%d",&n);
    int x,opt;
    while(n--)
    {
        scanf("%d%d",&opt,&x);
        if(opt==1) Insert(root,x);
        else if(opt==2) Remove(root,x);
        else if(opt==3) printf("%d\n",Getx_Rank(root,x));    
        else if(opt==4) printf("%d\n",GetRank(root,x));
        else if(opt==5) printf("%d\n",Getpre(x));
        else if(opt==6) printf("%d\n",Getnxt(x)); 
    }       
    return 0;
}
_BOSS_
关注
专栏目录
二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别
Linkai12138的博客
10-14 1597
1. 4者的区别与联系 二叉树，二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别： 根据百度百科给出的定义，它们之间的关系可以用下图表示，平衡二叉树（平衡二叉查找树，AVL）和红黑树都是二叉查找树的一种，区别就是平衡二叉树严格平衡，红黑树是弱平衡。 而AVL树由于实现比较复杂，而且插入和删除性能差，在实际环境下的应用不如红黑树。 2. 二叉查找树（BST） 2.1 定义 左子树的值小于根节点的值，右子树的值全部大于根节点的值；左右子树分别都是一颗二叉查找树。（递归定义） 3.1.2 缺点 可
平衡树Treap
sjystone的博客
04-05 220
平衡树Treap 由名字Treap可知，平衡树由tree和heap，即二叉搜索树and堆共同维护 即平衡树的每个节点都要储存key和val key满足二叉搜索树的性质，val满足堆的性质 ============================ 预备知识 1.二叉搜索树BST 满足以下两个条件的二叉树为BST 1.当前节点的左子树中的任何一个点的key都严格小于当前点的key 2.当前节点的右子树中的任何一个点的key都严格大于当前点的key BST的中序遍历： 按照 左子树 -> 根 -> 右
BZOJ 3224 普通平衡树 （BST+Treap）
邵光亮的博客
08-21 692
题目描述： 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入数值x。 删除数值x(若有多个相同的数，应只删除一个)。 查询数值x的排名(若有多个相同的数，应输出最小的排名)。 查询排名为x的数值。 求数值x的前驱(前驱定义为小于x的最大的数)。 求数值x的后继(后继定义为大于x的最小的数)。 输入格式 第一行为n，表示操作的个数。 接下来n行每...
BST与Treap讲解
weixin_30648963的博客
11-22 390
　　版权声明：参考李煜东《算法竞赛进阶指南》，本文在此基础上加以改动，主要目的是帮助理解算法，我认为此书中讲的很详细，于是打算记录下来给没看过的人了解，也为以后自己复习使用。 　　顺便推荐一下这本书。。。 正文开始 在认识平衡树之前，我们需要先认识BST。 目录： 一.BST 1.BST的建立 2.BST的检索 3.BST的插入 4.BST求前驱/后继 5.BST的节...
将BST变平衡(手撕AVL树)
miracleon的博客
08-22 520
力扣1382 什么是平衡二叉树(AVL)——知乎 [平衡二叉树(博客园)] (https://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html) 强调，手撕AVL并不是最优解，只是通解，时间复杂度是nlog(n)。 利用二叉搜索树的性质，中序遍历输出，然后以中间为root，递归构造树，效率更高，算是本题的最优解。 提交时发现，必须初始化叶子节点高度为1，0也不行 public AVLNode(int val){ this
有序数组转换为平衡二叉树(BST)
yang20141109的专栏
07-04 3127
把有序数组转换为平衡二叉树。TreeNode* buildTree(vector &nums,int start,int last) { int mid = (start + last) / 2; TreeNode *root = new TreeNode(nums[mid]); if(start == last) { return root; } if(start <= mid
Java AVL树：解决普通二叉查找树的不平衡问题详解
普通二叉查找树（BST）虽然易于理解，但在某些情况下可能会导致最坏的时间复杂度退化到O(n)，当数据插入有序时，树可能会变为单向倾斜，使得查找、插入和删除操作的时间复杂度不再保持在理想状态。AVL树正是为了解决...
Treap详解：随机优先级的平衡搜索树
二叉平衡树，又称Treap（Tree + Heap），是一种结合了二叉搜索树（BST）和堆数据结构特点的数据结构。Treap的关键特性在于每个节点除了包含一个键值用于排序外，还有一个随机的优先级，这使得它满足二叉搜索树的性质...
数据结构之Treap详解
09-04
与二叉堆不同，Treap不强制形成完全二叉树，因此其形状更加随机，有助于保持较好的平衡状态。 **1. Treap的构建与性质** 每个Treap节点包含四个属性： - `value`：存储节点的键值。 - `priority`：存储节点的...
二叉查找树（BST）的性质
weixin_34349320的博客
02-17 2322
二叉查找树的性质： 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 　　下图中这棵树，就是一颗典型的二叉查找树： 转载于:https://www.cnblogs.com/lxcmyf/p/8452085.html...
二叉查找树（BST） | 平衡二叉查找树（AVL） | 红黑树（RBT）
时间慢慢的博客
09-05 885
二叉查找树（BST） 特点：对任意节点而言，左子树（若存在）的值总是小于本身，而右子（若存在）的值总是大于本身。 查找：从根开始，小的往左找，大的往右找，不大不小的就是这个节点了； 插入：从根开始，小的往左，大的往右，直到叶子，就插入， 时间复杂度期望为Ο(logn)； 删除：如果是叶子节点，直接删除；如果不是，则去找这个节点左子树的最大值，与之交换；如果交换后还不是叶子节点就继续找做字数
二叉搜索树（BST）详解 先了解定义，性质，然后无非是遍历+访问都弄清楚
qq_15821487的博客
09-03 421
二叉搜索树（BST）详解 </h1> <div class="clear"></div> <div class="postBody"> <div id="cnblogs_post_body" class="blogpost-body blogpost-body-html"> 前言：平衡树的前置知识吧 二叉搜索树的定义： 二叉搜索树或者是...
判断二叉搜索树BST是否有效的两种方法
ccJun-的博客
08-17 1391
目录方法一：自顶向下递归方法二：利用BST中序遍历为升序序列的性质判断 方法一：自顶向下递归 由于BST是递归定义的，在判断某一节点是否符合BST性质的时候，不能只判断其左右子节点与该节点间的大小关系，如果这样判断的话，对于下图所示情况将给出错误的判断： 取而代之的是，我们应该判断对于任意节点，其是否在其应在的区间内。举例来说，对于上图中根节点5，由于是根节点，无区间要求；递归其左子树3，根据BST性质，3应该小于其根节点5，即其上边界为5，无下边界；递归3的左子树2，其上边界为3，无下边界；由于2的左右
【谈谈知识点】BST（无指针）
Cyan_rose
12-30 739
前言 联赛完了之后废了好长一段时间啊……甚至忘记了我有博客了~ 不过再怎么说还是要时常上来写写东西的嘛 前不久刚学了平衡树，大概也就花了四小时多理解+一天多调板子 以前暑假的时候觉得这玩意儿难得要死，现在想来好像没那么难啊…… 1.What is BST? 二叉搜索树（binary search tree），缩写为BST，具有以下性质： 1.所有非叶子结点至多拥有两个儿子（Left和Right）；...
二叉查找树（BST）：概念、基本操作和性能分析
16A086的博客
06-16 1747
文章目录定义声明基本操作初始化 MakeEmpty查找任意值 Find查找最小/最大值 FindMin/FindMax插入 Insert删除 Delete性能分析参考资料 二叉查找树 (Binary Search Tree, BST) 是二叉树在查找中的一种重要应用形式。 在这篇文章接下来的叙述中，做出以下假设： 尽管二叉树节点中存储的数据类型是任意的，但为了大小比较和理解的方便，本文中将数据类型指定为整数。 各个节点中的存储的数据是没有重复的。 定义 若一棵二叉树为二叉查找树，那么它必须满足： 对于
7.5 二叉查找树(BST)及平衡二叉树(AVL)的概念及基本运算
xutiantian1412的博客
08-01 738
经历二叉树的重重拷问，终于来到二叉查找树，又称二叉搜索树（BinarySearchTrees）。在第6章查找算法的介绍中，我们提到了树表查找/动态表查找，BST因为关键字有序，在查找时同样高效，并且易于对关键字的插入及删除操作。 二叉搜索树的基本概念 二叉搜索树是一棵二叉树。这样一棵树可以使用一个链表结构表示，其中每个结点就是一个对象。除了结点中的关键字外，每个结点还包含属性left、righ...
[模板总结] - 二叉搜索树 BST - 基础篇
ok1382038的博客
02-14 386
模板题目链接 BST查找 -Leetcode 270. Closest BST Value BST插入 -Leetcode 701. Insert Node in BST BST删除 -Leetcode 450. Delete Node in BST 二叉搜索树-BST 概述 BST是二叉树的一种，具备二叉树的结构性质：只有一个Root节点，每一个节点最多可以有左右两个子节点。BST自身的性质：每一个节点的左儿子数值一定比他小，右儿子的数值一定比他大。这个性质也使得BST的中序遍历输出结果是一...
BST(二叉搜索树),AVL(平衡二叉树)、RBT(红黑树)的区别
森明帮大于黑虎帮的博客
08-29 7627
文章目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值