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

目录

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),既是一棵二叉查找树,也是一个二叉堆。

【Multiset类库 旋转Treap(树堆)实现】(仿STL set |名次树 | 随机优先级扩展域)_第1张图片

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


二叉堆

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

堆总是满足下列性质:

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

  • 堆总是一棵完全二叉树。

【Multiset类库 旋转Treap(树堆)实现】(仿STL set |名次树 | 随机优先级扩展域)_第2张图片


BST

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

【Multiset类库 旋转Treap(树堆)实现】(仿STL set |名次树 | 随机优先级扩展域)_第3张图片

       


   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

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

【Multiset类库 旋转Treap(树堆)实现】(仿STL set |名次树 | 随机优先级扩展域)_第4张图片

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 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;
}

你可能感兴趣的:(算法,c++,算法,数据结构,深度优先,stl)