【第22期】观点:IT 行业加班,到底有没有价值?

treap(树堆)

原创 2016年08月28日 14:33:58

回顾: 二叉搜索树的定义与操作

二叉搜索树是指一颗空树或具有下列性质的树:

  • 任意节点的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
  • 任意节点的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
  • 任意节点的左、右子树也分别为二叉查找树;
  • 没有键值相等的节点

——from<维基百科>

二叉搜索树的操作包括:

  • 查找, 插入, 删除;
  • 查找小于X的元素个数/查找第k大的元素

treap的定义

treap(树堆)是一种随机二叉搜索树,相较于AVL树和红黑树等大部分二叉搜索树更加便于实现。树堆的结构并不由元素的添加顺序决定,而是随机的。因此,无论元素以何种方式添加到树堆,其树高的期望值总是一定的。

为了使树高的期望值总是一定的,每当树添加新值时,就会给此节点附加优先级(priority)。这种优先级与元素的大小和输入顺序无关,只通过随机数确定。treap总是会形成父节点的优先级高于子节点的二叉搜索树的形式。

由此可以得到treap的定义:

  • 树堆是一种随机的二叉搜索树,但是和二叉搜索树有相同的性质
  • 树堆的结构不由元素的添加顺序决定,而是随机的
  • 添加新节点时,给这个节点附加优先级(priority)。这种优先结构与元素大小关系和输入顺序无关,值通过随机数确定。
  • 树堆的条件:
    • 二叉搜索树的条件:对所有节点而言,左侧子树的节点元素值小于根节点元素值,右侧子树的节点元素值大于根节点
    • 堆的条件:所有节点的优先级都大于等于自身子节点的优先级

treap举例:

依序将1到7的整数插入到树结构中,并假设添加了随机生成的优先级,结果得到{37, 49, 13, 31, 65, 14, 25}。然后按照优先级从上到下重新排列节点得到第二张图。虽然保存元素相同,但在搜索第二张图中搜索时,因为树高更小,显然搜索地更快。

这里写图片描述
按顺序添加没有优先级限制

这里写图片描述
添加优先级,并按照优先级大小从上到下排列各节点

treap的实现

treap的实现主要有3个步骤,如下:

step1: 定义结构体/对象

typedef int keyType;
//保存树堆节点
struct node{
    //保存节点的元素
    keyType key;
    //当前节点的优先级(priority)
    //将当前节点作为根节点的子树的大小(size)
    int priority, size;
    //两个子节点的指针
    node *left, *right;
    //生成器生成随机数后,初始化size和left/right指针
    node(const keyType &_key)
        : key(_key), priority(rand()), size(1), left(NULL), right(NULL){}

    void setLeft(node *newleft){left = newleft; calcSize();}
    void setRight(node *newRight){right = newRight; calcSize();}

    //更新size成员
    void calcSize()
    {
        size = 1;
        if(left) size += left->size;
        if(right) size += right->size;
    }
};

代码中首先需要注意查看树堆节点中的对象,它不仅拥有元素key,还拥有优先级priority。 生成节点时,利用rand()函数返回赋值,还需要关注将自己用作子树的根,并保存子树节点个数的size()成员函数。此数值在每次left或right变更时自动更新,利用它就能够很容易地实现查找第k个元素或计算小于X的元素个数的运算。

step2:节点的添加和“分割”运算

向树堆中添加新节点的算法,主要在于保证其为二叉搜索树的条件下,还添加了优先级的相关制约条件。

假设现在向以root为根节点的树堆添加新节点node,先判断优先级

  • root更高,node添加至下一级,递归调用即可;
  • 如果node优先级高于root,将node的元素值用作标准值,“分割”原来的树结构即split(root, key)函数,该函数将以root为根的子树分割成元素值小于key和大于key的节点。此时再用node替换掉原来的root,成为此树的新根,而split()得到的一对节点将成为node 的后代节点。

首先给出添加新节点的insert()函数,这里假设split()函数已经有定义,返回的是pair类型,first存储小于key的子树的根节点指针,second存储大于key的子树的根节点:

//向以root为根的树堆添加新节点node后,
//返回添加完毕后的新树堆的根
node* insert(node *root, node *po)
{
    if(root == NULL) return po;
    //需要用node替换根节点,将该子树一分为二
    //分别充当左右侧后代节点。
    if(root->priority < po->priority)
    {
        nodePair splitted = split(root, po->key);
        po->setLeft(splitted.first);
        po->setRight(splitted.second);
        return po;
    }
    else if(root->key < po->key)
        root->setRight(insert(root->right, po));
    else
        root->setLeft(insert(root->left, po));
    return root;
}

insert()函数向以root为根的子树添加node后返回新树的根,因为向子树添加新节点后,其根节点可能不同于原根节点。为此每次调用insert()时都会电泳setLeft()或setRight().

理解了insert的过程,下来再展示split的代码块:

typedef pair<node*, node*> nodePair;
//将以root为根的树堆分割成为所有元素值小于key的树堆
//以及大于key的树堆
nodePair split(node *root, keyType key)
{
    if(root == NULL) return nodePair(NULL, NULL);
    //如果更节点的元素值小于key,则分割右子树
    if(root->key < key)
    {
        nodePair rs = split(root->right, key);
        root->setRight(rs.first);
        return nodePair(root, rs.second);
    }
    //如果根节点的元素大于key,则分割左子树
    nodePair ls = split(root->left, key);
    root->setLeft(ls.second);
    return nodePair(ls.first, root);
}

如果有指向树堆根节点的指针root,就可以利用下列代码添加新值value:

root = insert(root, new node(value));

step3: 节点的删除和“合并”运算

首先来介绍一下一般二叉搜索树的删除节点操作——“合并”。如果想要删除节点t, 需要首先生成合并t的两个子树的树结构,然后利用此树结构替换将t用作根节点的子树。如下图所示:
删除前

删除前的二叉树如上,假设现在要删除值为72的节点,那么要将其子树合并,然后代替72成为31的右孩子。删除后的二叉树如下:

这里写图片描述

假设合并树结构A和B时,A的最大元素小于B的最小元素。A和B是节点t的左右子树, 所以这种性质总是成立。那么可以将A的根节点a用作合并后的树的根节点以合并两个子树。此时,a的左侧子树中的元素都将小于a中的元素值,而右侧子树的元素和B的所有元素都大于a中元素值。因此,以递归方式合并右侧子树和B中所有元素后,将合并后的树结构用作a的右侧子节点即可。

由以上过程可知,删除节点的操作至少需要删除erase()和合并merge()两个函数的操作。

树堆节点的删除和上面所述类似,只不过合并两个子树时,将通过优先级决定哪个子树的根节点将成为树堆的根节点。

首先给出在树堆中merge()合并函数的代码,其返回a和b两颗子树合并后得到的根节点:

//a 和 b 是两个树堆,max(a) < min(b)时合并
node* merge(node *a, node *b)
{
    if(a == NULL) return b;
    if(b == NULL) return a;
    if(a->priority < b->priority)
    {
        b->setLeft(merge(a, b->left));
        return b;
    }
    a->setRight(merge(a->right, b));
    return a;
}

正如注释上所说,只有子树a中的最大元素小于子树b中的最小元素时才能合并,否则合并过程就会乱序。

下面是树堆中删除erase()操作的代码:

//以root为根的树堆中,删除key后返回树堆的根
node* erase(node *root, keyType key)
{
    if(root == NULL) return root;
    //删除root后合并两个子树并返回
    if(root->key == key)
    {
        node *ret = merge(root->left, root->right);
        delete root;
        return ret;
    }
    if(key < root->key)
        root->setLeft(erase(root->left, key));
    else
        root->setRight(erase(root->right, key));
    return root;
}

treap的操作

我们前面提到了treap的操作除了插入,删除,查找以外,还有求小于x的元素个数,按照大小顺序排序时查找第k个元素。利用二叉搜索树可以很容易实现这些运算。

但是大部分程序设计语言的标准库并不支持这些操作,所以就需要快速编写treap来实现,node类保存了其子树的大小size,所以实现这种操作并不难。

treap操作之一:查找第k个元素

以root为根的子树由左子树,右子树,root本身组成。只要知道各子树的大小,就能知道第k个节点在哪里。

这里假设左侧子树的大小为 L 时,可以分为如下三种情况考虑:

  • k ≤ L : 第k个节点属于左侧子树;
  • k = L + 1: 根节点是第k个节点;
  • k > L + 1 : 右侧子树的第k - (L + 1)个接待你是第k个节点。

如下所示代码是算出第k个元素的kth()函数的源代码。kth()并没有特意考虑需要处理的树结构是树堆,所以此函数不仅适用于树堆,而且适用于能够得出各子树大小的二叉搜索树。

//返回 以root为根的树中第k个元素
node* kth(node *root, int k)
{
    int leftSize = 0;
    if(root->left != NULL)
        leftSize = root->left->size;
    if(k <= leftSize) return kth(root->left, k);
    if(k == leftSize + 1) return root;
    return kth(root->right, k - leftSize - 1);
}

kth()函数的时间复杂度和树高成正比。

treap操作之二: 计算小于x的元素个数

搜索二叉树另一个操作是给出特定范围[a, b)时,算出此范围内所有元素个数。显然编写能够计算并返回小于x的元素个数的countLessThan(x)函数就能轻松实现此操作,因为[a, b)范围内元素个数可以用countLessThan(b) - countLessThan(a)算出。

而countLessThan(x)函数就是对查找函数的简单变形。首先判断root中的元素是否大于等于x:

  • 如果是,则root和右侧子树中的元素全都大于x,递归左子树即可;
  • 如果root中的元素小于x,则左侧元素都小于x。因此,左侧子树中的所有元素都要算入答案。而在右侧子树中,利用递归方式算出小于x的元素个数。最终将左右侧小于x的元素个数与根节点个数相加就能得到答案。

下面是countLessThan(x)函数的源代码,此代码也同样并不只是用于树堆,只要是节点中存储了子树大小的二叉搜索树,都能正确运行此函数。

//返回小于key的元素个数的源代码
int countLessThan(node *root, keyType key)
{
    if(root == NULL) return 0;
    if(root->key >= key)
        return countLessThan(root->left, key);
    int ls = (root->left ? root->left->size : 0);
    return ls + 1 + countLessThan(root->right, key);
}

总结与例题

以上两种实现查找第k小的元素、小于key的元素个数的操作的二叉搜索树的结构又被称为名次树(rank tree)。下面给出一道例题:
https://algospot.com/judge/problem/read/INSERTION (可能需要翻墙)
下面给出这道题的翻译:
翻转插入排序
此题的思路如下:

  1. 只要知道最后一个数值A[N-1]向左移动了几次,就能猜出A[N-1]中的数值。

  2. 例如{0,1,1,2,3},最后一个数值A[4]向左移动3次,说明1~5的数值中,比A[4]大的数值有3个,由此得知A[4] = 2。已知2是A[4]中的数值,所以A[3]中的数值只能是1,3,4,5之一。这些数中,比A[3]大的数值有两个,可知A[3] = 3

  3. 按这种方法设计算法,需考虑能放入A[i]的各个数值如何保存。为实现此算法,必须迅速在候选集合中找出第k个元素并删除。利用二叉搜索树在O(logN)的时间内完成

具体代码就不在这里给出,如果要进一步了解此题的代码,可参考

具宗万《算法问题实战策略》22.8 解题: 翻转插入排序

treap的题目还有2010天津区域赛题目Graph and Queries,这里同样给出链接
https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&category=393&page=show_problem&problem=3032

其实现解法与如何使用treap可参考

《算法竞赛入门经典训练指南》3.5.2节例题20

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

Treap(树堆)图解与实现

前面我们介绍了AVL树,伸展树,它们都是二叉搜索树,二叉搜索树的主要问题就是其结构与数据相关,树的深度可能会很大,Treap树就是一种解决二叉搜索树可能深度过大的另一种数据结构。 Treap=Tre...

随机二叉平衡树treap个人总结

二叉查找树 二叉查找树(Binary Search Tree),或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; ...

程序员升职加薪指南!还缺一个“证”!

CSDN出品,立即查看!

Treap(树堆)

Treap,就是有另一个随机数满足堆的性质的二叉搜索树,其结构相当于以随机顺序插入的二叉搜索树。其基本操作的期望复杂度为O(log n)。     其特点是实现简单,效率高于伸展树并且支持大部分基本功...

素数筛选法

这种方法效率较高,能处理的数据也很多,缺点就是数组必须很大,如果

链表应用--约瑟夫环

约瑟夫环是一个数学的应用问题:已知n个人(以编号1,2,3...n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律重...

平衡二叉树(AVL)图解与实现

平衡二叉树(Balanced BinaryTree)又被称为AVL树。它具有以下性质:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。 平衡二叉树一般是...

C++面试笔试经典题集

(1) char str[]="hello"; printf("%d\n",sizeof(str)); 解析:答案是6,包含一个结束符 '\0'。 (2)下面哪种情况下B不能隐式转换为A? A: cl...

c++ 深复制

浅复制(浅克隆) 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。 深复制(深克隆)...

Java基础 - 树堆(Treap = tree+heap)

一棵treap是一棵修改了结点顺序的二叉查找树,如图,显示一个例子,通常树内的每个结点x都有一个关键字值key[x],另外,还要为结点分配priority[x],它是一个独立选取的随机数。

偷懒专用平衡树——Treap

Treap的实现
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)