算法导论读书笔记（20）van Emde Boas树

第五部分 高级数据结构

第20章 van Emde Boas树

van Emde Boas树支持优先队列操作以及一些其他操作，每个操作最坏情况运行时间为O(lglgn)。而这种数据结构限制关键字必须为0~n-1的整数且无重复。

1. 基本方法

直接寻址

维护一个u位的数组A[0..u-1]，以存储一个值来自全域{0, 1, 2, …, u-1}的动态集合。虽然利用位向量方法可以使insert, delete和member操作的运行时间显O(1)，然而其余操作minimum, maximum, successor和predecessor在最坏情况下仍需Θ(u)的运行时间，这是因为操作需要扫描Θ(u)个元素。

叠加的二叉树结构

在位向量上方叠加的一棵位二叉树的方法，来缩短对位向量的长扫描。位向量的全部元素组成了二叉树的叶子，并且每个内部结点为1当且仅当其子树中任一个叶结点包含1。换句话说，内部结点中存储的位就是其两个孩子的逻辑或。

使用这种树结构和未经修饰的位向量，具有最坏情况运行时间为Θ(u)的操作如下:
1. 查找集合中的最小值，从树根开始，箭头朝下指向叶结点，总是走最左边包含1的结点。
2. 查找集合中的最大值，从树根开始，箭头朝下指向叶结点，总是走最右边包含1的结点。
3. 查找x的后继，从x所在的叶结点开始，箭头朝上指向树根，直到从左侧进入一个结点，其右孩子结点z为1。然后从结点z出发箭头向下，始终走最左边包含1的结点（即查找以z为根的子树中的最小值）。
4. 查找x的前驱，从x所在的叶结点开始，箭头朝上指向树根，直到从右侧进入一个结点，其左孩子结点z为1。然后从结点z出发箭头向下，始终走最右边包含1的结点（即查找以z为根的子树中的最大值）。

叠加的一棵高度恒定的树

假设全域的大小为u = 2 ^ 2k，这里k为某个整数，那么sqrt(u)是一个整数。我们叠加一棵度为sqrt(u)的树，来代替位向量上方叠加的二叉树。结果树的高度总是为2。

1. 查找最小（最大）值，在summary数组中查找最左（最右）包含1的项，如summary[i]，然后在第i个簇内顺序查找最左（最右）的1。
2. 查找x的后继（前驱），先在x的簇中向右（左）查找。如果发现1，则返回这个位置作为结果；否则，令i =⌊ x / sqrt(u)⌋，然后从下标i开始在summary数组中向右（左）查找。找到第一个包含1的位置就得到这个簇的下标。再在该簇中查找最左（最右）的1，这个位置的元素就是后继（前驱）。
3. 删除值x，设i =⌊ x / sqrt(u)⌋。将A[x]置为0，然后置summary[i]为第i个簇中所有位的逻辑或。

2.递归结构

一个给定的值x在簇编号⌊ x / sqrt(u)⌋中。如果把x看做lgu位的二进制整数，那么簇编号⌊ x / sqrt(u)⌋由x中最高(lgu)/2位决定。在x簇中，x出现在位置x mod sqrt(u)中，是由x中最低(lgu)/2位决定。因此定义以下函数：
1. high(x) = ⌊ x / sqrt(u)⌋
2. low(x) = x mod sqrt(u)
3. index(x, y) = x sqrt(u) + y

1. 原型van Emde Boas结构

对于全域{0, 1, 2, …, u-1}，定义原型van Emde Boas结构，记作proto-vEB(u)。每个proto-vEB(u)的结构都包含一个给定全域大小的属性u。另外，它包含以下特征：
1. 如果u = 2，那么它是基础大小，只包含一个两个位的数组A[0..1]。
2. 否则，对某个整数k >= 1，u = 2 ^ (2^k)，于是有u >= 4。除了全域大小u之外，prote-vEB(u)还具有以下属性：a. 一个名为summary的指针，指向一个prote-vEB(sqrt(u))结构。b. 一个数组cluster[1..sqrt(u)-1]，存储sqrt(u)个指针，每个指针都指向一个prote-vEB(sqrt(u))结构。

2.原型van Emde Boas结构上的操作

判断一个值是否在集合中

Prote-vEB-Member(V, x)    if V.u == 2        return V.A[x]    else        Prote-vEB-Member(V.cluster[high(x)], low(x))

查找最小元素

Proto-vEB-Minimum(V)    if V.u == 2        if V.A[0] == 1            return 0        else if V.A[1] == 1            return 1    else        min-cluster = Proto-vEB-Minimum(V.summary)        if min-cluster == NIL            return NIL        else            offset = min-cluster = Proto-vEB-Minimum(V.cluster[min-cluster])            return index(min-cluster, offset)

查找后继

Proto-vEB-Successor(V, x)    if V.u == 2        if x == 0 and V.A[1] == 1            return 1        else            return NIL    else        offset = Proto-vEB-Successor(V.cluster[high(x)], low(x))        if offset != NIL            return index(high(x), offset)        else            succ-cluster = Proto-vEB-Successor(V.summary, high(x))            if succ-cluster == NIL                return NIL            else                offset = Proto-vEB-Minimum(V.cluster[succ-cluster])                return index(succ-cluster, offset)

插入元素

Proto-vEB-Insert(V, x)    if V.u == 2        V.A[x] = 1    else        Proto-vEB-Insert(V.cluster[high(x)], x)        Proto-vEB-Insert(V.summary, high(x))

3.van Emde Boas树及其操作

proto-vEB结构已接近运行时间为O(lglgu)的目标，其缺点是大多数操作需要进行多次递归。
重定义：
1. high(x) = ⌊ x / ⌊sqrt(u)⌋ ⌋
2. low(x) = x mod ⌊sqrt(u)⌋
3. index(x, y) = x * ⌊sqrt(u)⌋ + y

1.van Emde Boas树

一棵vEB树含有proto-vEB结构中没有的两个属性：
1. min存储vEB树中的最小元素；
2. max存储vEB树中的最大元素；
存储在min中的元素并不出现在任何递归的vEB(⌊sqrt(u)⌋)树中，这些树是由cluster数组指向它们的。
存储在min中的元素不出现在任何簇中，而存储在max中的元素却不是这样。
在一棵不包含任何元素的vEB树中，不管全域的大小u如何，min和max均为NIL。
min和max属性是减少vEB树上这些操作的递归调用次数的关键，这两个属性有4个方面的作用：
1. minimum和maximum操作不需要递归，因为可以直接返回min和max的值；
2. successor操作可以避免一个用于判断值x的后继是否位于high(x)中的递归调用。这是因为x的后继位于x簇中，当且仅当x严格小于x簇的max。对于prodecessor和min情况，可以对照得到。
3. 通过min和max的值，可以在常数时间内告知一棵vEB树是否为空、仅含一个元素或两个以上元素。如何min和max都为NIL，那么vEB树为空，如何min和max 都不为NIL但彼此相等，那么vEB树仅含一个元素。如果min和max***都不为NIL且不等，那么vEB树包含两个或两个以上元素*。
4. 如果一棵vEB树为空，那么可以仅更新它的min和max值为实现插入一个元素。

2.van Emde Boas树的操作

查找最小元素和最大元素

vEB-Tree-Minimum(V)    return V.min

vEB-Tree-Maximum(V)    return V.max

判断一个值是否在集合中

vEB-Tree-Member(V, x)    if x == V.min or x == V.max        return true    else if V.u == 2        return false    else        return vEB-Tree-Member(V.cluster[high(x)], low(x))

查找后继和前驱

vEB-Tree-Successor(V, x)    if V.u == 2        if x == 0 and V.max == 1            return 1        else            return NIL    else if V.min != NIL and x < V.min        return V.min    else        max-low = vEB-Tree-Maximum(V.cluster[high(x)])        if max-low != NIL and low(x) < max-low            offset = vEB-Tree-Successor(V.cluster[high(x)], low(x))            return index(high(x), offset)        else            succ-cluster = vEB-Tree-Successor(V.summary, high(x))            if succ-cluster == NIL                return NIL            else                offset = vEB-Tree-Miniimum(V.cluster[succ-cluster])                return index(succ-cluster, offset)

vEB-Tree-Predecessor(V, x)    if V.u == 2        if x == 1 and V.min == 0            return 0        else            return NIL    else if V.max != NIL and x > V.max        return V.max    else        min-low = vEB-Tree-Minimum(V.cluster[high(x)])        if min-low != NIL and low(x) > min-low            offset = vEB-Tree-Predecessor(V.cluster[high(x)], low(x))            return index(high(x), offset)        else            pred-cluster = vEB-Tree-Predecessor(V.summary, high(x))            if pred-cluster == NIL                if V.min != NIL and x > V.max                    return V.min                else                    return NIL            else                offset = vEB-Tree-Minimum(V.cluster[pred-cluster])                return index(pred-cluster, offset)

插入一个元素

vEB-Empty-Tree-Insert(V, x)    V.min = x    V.max = x

vEB-Tree-Insert(V, x)    if V.min == NIL        vEB-Empty-Tree-Insert(V, x)    else        if x < V.min            exchange x with x.min        if V.u > 2            if vEB-Tree-Minimum(V.cluster[high(x)]) == NIL                vEB-Tree-Insert(V.summary, high(x))                vEB-Empty-Tree-Insert(V.cluster[high(x)], low(x))            else                vEB-Tree-Insert(V.cluster[high(x)], low(x))        if x > V.max            V.max = x

删除一个元素

vEB-Tree-Delete(V, x)    if V.min == V.max        V.min = NIL        V.max = NIL    else if V.u == 2        if x == 0            V.min = 1        else            V.min = 0        V.max = V.min    else        if x == V.min            first-cluster = vEB-Tree-Minimum(V.summary)            x = index(first-cluster, vEB-Tree-Minimum(V.cluster[first-cluster]))            V.min =x        vEB-Tree-Delete(V.cluster[high(x)], low(x))        if vEB-Tree-Minimum(V.cluster[high(x)]) == NIL            vEB-Tree-Delete(V.summary, high(x))            if x = V.max                summary-max = vEB-Tree-Maximum(V.summary)                if summary-max == NIL                    V.max = V.min                else                    V.max = index(summary-max, vEB-Tree-Maximum(V.cluster[summary-max]))        elseif x == V.max            V.max = index(high(x), vEB-Tree-Maximum(V.cluster[high(x)]))