【Multiset类库旋转Treap(树堆)实现】（仿STL set |名次树 | 随机优先级扩展域）

XNB's Not a Beginner

已于 2023-12-19 14:33:51 修改

阅读量870

点赞数 21

分类专栏： ADT数据结构实现语言特性 Modern Cpp 文章标签： c++ 算法数据结构深度优先 stl

于 2023-12-13 23:33:32 首次发布

本文链接：https://blog.csdn.net/RFoer/article/details/134982288

版权

ADT数据结构实现同时被 2 个专栏收录

46 篇文章 0 订阅

订阅专栏

语言特性 Modern Cpp

38 篇文章 0 订阅

订阅专栏

Treap简介

Treap类的框架

Node结构体的实现

treap构造、析构

默认构造

移动构造

拷贝构造

public主调函数实现（调用private中的辅助函数）

private辅助函数

获取子树大小：getSiz(Node *o)->int

旋转：rotate(Node *&o,int d)->void(核心函数)

插入：insert(Node *&o,int x)->void

删除：erase(Node *&o,int x)->int

销毁：del(Node *o)->void

第k小元素：kth_element(Node *o,int k)->Node *

查询x排名：rank(Node *o,int x,int cur)->int

查找：find(Node *o,int x)->Node *

上紧界：lower_bound(Node *o,Node *f,int x)->Node *

上宽界： upper_bound(Node *o,Node *f,int x)->Node *

遍历：iterate(Node *o,void(*visit)(int val) )->void

树高：height(Node *o)->int

树宽：width(Node *o)->int

Treap简介

树堆(treap = tree + heap),既是一棵二叉查找树，也是一个二叉堆。

每个节点有一个可比较的关键字对：priority、val。这两个关键字分别维护这个数据结构的(极大)堆性质和BST性质。

二叉堆

二叉堆是基于完全二叉树的基础上，加以一定的条件约束的一种特殊的二叉树

堆总是满足下列性质：

堆中某个节点的值总是不大于或不小于其父节点的值；

堆总是一棵完全二叉树。

BST

二叉查找树（Binary Search Tree），简写BST，是满足某些条件的特殊二叉树。任何一个节点的左子树上的点，都必须小于当前节点。任何一个节点的右子树上的点，都必须大于当前节点。

treap

普通的BST有很强的不稳定性，在不降或不升序列按序插入中，整棵树会退化成单链表操作复杂度也从logN提高为N的线性复杂度。而treap通过子树单旋来动态维护这个树形态（像heap一样在pop实现中，元素下沉和上浮的调整），使树高平衡（基于随机的近似平衡，不是AVL的严格条件：平衡因子绝对值小于等于1）保证删除查询插入三大操作的平均期望复杂度保持在logN级别。

同时Treap 通过随机附加域来维护堆的性质，只用到了左旋和右旋，编程复杂度比Splay小，并且在两者可完成的操作速度有明显优势（名次树实现、SCC连通分量维护与合并等）

Treap类的框架

基本操作

构造函数
析构函数
插入
删除
查找
查询第k小元素
查询元素x排名
查询最大值
查询最小值
查询第一个大于等于x的元素
查询第一个严格大于x的元素
中序遍历
查询树的大小
查询树是否为空

namespace TREAP{
/*命名空间 防止和STL库命名冲突*/
 class Treap{
    struct Node{...}
    /*内嵌节点结构体*/
    public:
        Treap(void){...}/*默认构造*/
        Treap(const Treap& other){...}/*拷贝构造*/
        Treap(Treap&& other){...}/*移动构造*/
        ~Treap(void){...}/*析构*/

        void insert(int x){...}/*插入*/
        bool erase(int x){...}/*删除*/
        const Node *rank(int x){...}/*排名*/
        const Node * kth_element(void){...}/*第k小元素*/
        const Node *max_element(void){...}/*最大元素*/
        const Node *min_element(void){...}/*最小元素*/
        size_t size(void){...}/*树的规模*/
        const Node *find(int x){...}/*查询*/
        bool empty(void){...}/*是否为空*/
        const Node *lower_bound(int x){...}/*上紧边界*/
        const Node *upper_bound(int x){...}/*上宽边界*/
        void iterate(void(*visit)(int val) ){...}/*（中序）遍历*/
    private:
        Node *root;/*树根*/
        /*...辅助函数*/
 };
};

Node结构体的实现

构造函数
析构函数
优先级比较
元素大小比较
更新子树大小

        Node *childs[2];/*二叉链表 数组存储 多路链表方便下标索引*/
		int val;/*元素值*/
		int prior;/*heap优先级*/
		int siz;/*以该节点为根的树的大小*/
		int cnt;/*元素重合数（权值）*/

		Node(int val,int prior = rand(),/*随机生成优先级修正值*/
			int siz = 1,int cnt = 1,
			Node *lch = nullptr,Node *rch = nullptr)
				:val(val),prior(prior)
				,siz(siz),cnt(cnt)
			{
				childs[0] = lch;
				childs[1] = rch;
			}
		Node(Node&& other)	/*移动构造*/
			:val(other.val),prior(other.prior)
			,siz(other.siz),cnt(other.cnt)
			{
				childs[0] = other.childs[0];
				childs[1] = other.childs[1];/*转让堆内存所有权*/
				other.childs[0] = other.childs[1] = nullptr;/*置空防止野指针*/
			}
		Node(const Node& other)	/*拷贝构造*/
			:val(other.val),prior(other.prior)
			,siz(other.siz),cnt(other.cnt)
			{
				int i;
				for(i = 0;i < 2;++i)/*类似树的遍历 当子树非空 new关键字触发拷贝构造的递归调用*/
					childs[i] = other.childs[i]?new Node(*(other.childs[i]))
												:nullptr;
			}
			
		inline bool operator<(const Node &rhs)const{return prior < rhs.prior;}
/*重载比较运算符 基于优先级比较大小 便于动态调整节点的层级 维护heap的性质*/
		inline int cmp(int x)const{return x == val?-1:(x < val?0:1);}
/*基于元素值比较大小 便于元素查询 维护BST的性质*/
		inline void maintain(){siz = Treap::getSiz(childs[0])+
							  Treap::getSiz(childs[1])+1;}
/*用于旋转函数rotate的次调函数，旋转后形态发生变化 更新子树规模*/

treap构造、析构

默认构造

Treap(void)
	:root(nullptr)
	{}

移动构造

转移堆内存所有权绕过析构和拷贝将亡的临时右值对象对系统资源的消耗

Treap(Treap &&other)
		:root(*(other.root))
	{other.root = nullptr;}

拷贝构造

Treap类的拷贝构造通过内嵌结构Node的拷贝构造函数间接实现（由new触发的拷贝构造函数递归调用）实现逻辑如下

Node(const Node& other)	
		:val(other.val),prior(other.prior)
		,siz(other.siz),cnt(other.cnt)
	{
		int i;
		for(i = 0;i < 2;++i)
			childs[i] = other.childs[i]?new Node(*(other.childs[i])):nullptr;
        /*类似树的遍历 当子树非空 new关键字触发拷贝构造的递归调用*/
        /*子树判空 子树空为递归出口条件*/
			}

	Treap(const Treap &other){
			if(root)del(root);/*先销毁原树*/
			root = new Node(*(other.root));	/*拷贝root*/
		}

public主调函数实现（调用private中的辅助函数）

void insert(int x){insert(root,x);}

bool erase(int x){return erase(root,x);}

const Node *kth_element(int x){return kth_element(root,x);}

int rank(int x){return rank(root,x,-1);}

const Node *max_element(void){
    Node * o = root,*p;
	while((p = o->childs[1]))o = p;
	return o;	
}
const Node *min_element(void){
	Node * o = root,*p;
	while(o && (p = o->childs[0]))o = p;
	return o;	
}
size_t size(void){return getSiz(root);}

const Node *find(int x){return find(root,x);}

bool empty(void){return root == nullptr;}

const Node *lower_bound(int x){return lower_bound(root,nullptr,x);}

const Node *upper_bound(int x){return upper_bound(root,nullptr,x);}

void iterate(void (*visit)(int val)){iterate(root,visit);}

private辅助函数

**获取子树大小：getSiz(Node *o)->int**

获取以传入节点为根的子树大小

空树返回0

static inline int getSiz(Node *o){return o?o->siz:0;}

**旋转：rotate(Node *&o,int d)->void(核心函数)**

单旋转函数在删除插入函数的递归回溯中自底向上的调整树的形态使一直满足堆的性质

int d为需要提拔的是左子树还是右子树 | 左：d == 0 -> zig 、右:d == 1 -> zag

传入引用指针因为树根会在旋转过程中发生变化

void rotate(Node *&o,int d){
	Node *k = o->childs[d^1];
	o->childs[d^1] = k->childs[d];
	k->childs[d] = o;
	o->maintain();k->maintain();
	o = k;
}

**插入：insert(Node *&o,int x)->void**

插入函数：传入引用指针也可以用接受回传指针的方式防止局部指针变量的销毁和堆内存地址丢失

在递归过程中维护子树大小和元素数目

void insert(Node *&o,int x){
	if(nullptr == o){o = new Node(x);return;}
	++(o->siz);int d = o->cmp(x);
	if(~d){++(o->cnt);return;}
	insert(o->childs[d],x);
	if(*(o->childs[d]) > *o)rotate(o,d^1);
}

**删除：erase(Node *&o,int x)->int**

删除函数返回值为删除失败与否 | 成功：1 失败：0

int erase(Node *&o,int x){
	if(!o)return 0;
	int d = o->cmp(x);
	if(!(~d))if(erase(o->childs[d],x))--(o->siz);
	else{
		if(!o->childs[0]){Node *t = o;o = o->childs[0];delete t;return 1;}
		else if(!o->childs[1]){Node *t = o;o = o->childs[1];delete t;return 1;}
		int dd = ~(int)(*(o->childs[0]) < *(o->childs[1]));
		rotate(o,dd);erase(o->childs[dd],x);
	}
}

**销毁：del(Node *o)->void**

销毁函数后序遍历实现

void del(Node *o){
	if(o){
		del(o->childs[0]);del(o->childs[1]);
		delete o;o = nullptr;
	}
}

第k小元素：kth_element(Node o,int k)->Node

top/bot-k函数通过维护的每个子树的大小进行递归得到答案

Node *kth_element(Node *o,int k){
	if(k < o->siz+1)return kth_element(o->childs[0],k);
	else if(k > o->siz + o->cnt)
        return kth_element(o->childs[1],k-(o->siz + o->cnt));
	else return o;
}

**查询x排名：rank(Node *o,int x,int cur)->int**

排名函数查询给定元素x所处的排名

cur为当前递归层级内位于x前面的元素个数

int rank(Node *o,int x,int cur){
	if(!o)return -1;
	if(x == o->val)return getSiz(o->childs[0])+cur+1;
	if(x < o->val)return rank(o->childs[0],x,cur);
	else return rank(o->childs[1],x,cur+o->siz+o->cnt);
}

查找：find(Node o,int x)->Node

查询给定元素x 递归实现

Node *find(Node *o,int x){
	if(!o)return nullptr;
	if(o->val == x)return o;
	if(o->val < x)return find(o->childs[0],x);
	else return find(o->childs[1],x);
}

上紧界：lower_bound(Node o,Node f,int x)->Node *

上紧界查询第一个大于等于给定元素x的元素

Node *f 为x的父节点

Node *lower_bound(Node *o,Node *f,int x){
	if(!o)return f;
	if(o->val == x)return o;
	if(o->val < x)return lower_bound(o->childs[0],o,x);
	return lower_bound(o->childs[1],o,x);
}

上宽界： upper_bound(Node o,Node f,int x)->Node *

上宽界查询第一个严格大于给定元素x的元素

Node *upper_bound(Node *o,Node *f,int x){
		if(!o)return f;
		if(o->val <= x)return lower_bound(o->childs[0],o,x);
		return lower_bound(o->childs[1],o,x);
}

**遍历：iterate(Node o,void(visit)(int val) )->void**

遍历函数采用中序遍历可以打印有序序列

visit 是void(*)(int)型的函数指针对节点的数据域val操作

void iterate(Node *o,void(*visit)(int val)){
	if(o){
		iterate(o->childs[0],visit);
		visit(o->val);
		iterate(o->childs[1],visit);
	}
}

**树高：height(Node *o)->int**

求树的最大深度也为树根到叶子节点的最大外部路径长度体现了DC递归思想

int height(Node *o){
	if(!o)return 0;
	if(!o->childs[0] && !o->childs[1])return 1;
	return 1 + std::max(height(o->childs[0]),height(o->childs[1]));
}

**树宽：width(Node *o)->int**

求树的纵向宽度 BFS在线记录实现

int width(Node *o){
	if(!o)return 0;
	int m = 0;
	std::queue<Node *> Q;Q.push(o);
	while(!Q.empty()){
		int s = Q.size();
		m = std::max(m,s);
		while(s--){
			Node *o = Q.front();Q.pop();
			int i;
			for(i = 0;i < 2;++i)
				if(o->childs[i])
                    Q.push(o->childs[i]);
		}
	}
	return m;
}

XNB's Not a Beginner

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Multiset类库旋转Treap(树堆)实现】（仿STL set |名次树 | 随机优先级扩展域）

树堆(treap = tree + heap),既是一棵二叉查找树，也是一个二叉堆。。这两个关键字分别维护这个数据结构的(极大)堆性质和BST性质。普通的BST有很强的不稳定性在不降或不升序列按序插入中整棵树会退化成单链表操作复杂度也从logN提高为N的线性复杂度。
复制链接

扫一扫