最大最小堆介绍

最大最小堆
1. 定义：

最小最大堆是一棵完全二叉树，且其中每个元素有一个key数据成员。树的各层交替为最小层和最大层。根结点在最小层。设x是最小最大堆的任意结点。若x在最小（最大）层上，则x中的元素的key值在以x为根的子树的所有元素中是最小（最大）的。位于最小（最大）层的结点称为最小（最大）结点。

2. 特征：

（1） 插入一个具有任意key值的元素

（2） 删除key值最大的元素

（3） 删除key值最小的元素

3. 例如：

4. 插入10

template<class Type>

void MinMaxHeap<Type>::Insert(constElement<Type>&x )
{

if(n == MaxSize ) { MinMaxFull( ); return;}

n++;

int p = n/2; //p是新结点的双亲

if (!p) {h[1] = x; return;} // 插入初始时为空的堆

switch (level(p)) {

case MIN:

if (x.key < h[p].key) { // 沿着最小层检查

h
=h[p];

VerifyMin(p, x);

}

else VerifyMax(n, x); // 沿着最大层检查

break;

case MAX:

if (x.key > h[p].key) { // 沿着最大层检查

h
=h[p];

VerifyMax(p, x);

}

else VerifyMin(n, x); // 沿着最小层检查

} //switch结束

} // Insert结束

函数level确定一个结点是位于最小最大堆的最小层，还是位于最大层。当élog2(j + 1)ù为偶数时，结点j位于最大层，否则位于最小层

函数VerifyMax从最大结点i开始，沿着从结点i到最小最大堆的根的路径检查最大结点，查找插入元素x的正确结点。在查找过程中，key值小于x.key的元素被移到下一个最大层

函数VerifyMin与VerifyMax类似，所不同的是，前者从最小结点i开始，沿着从结点i到根的路径检查最小结点，将元素x插入正确位置。

分析：由于n个元素的最小最大堆有O(logn)层，成员函数Insert的时间复杂性是O(logn)。

template<class Type>

void MinMaxHeap<Type>::VerifyMax(int i,
const Element<KeyType>&x ) { // 沿着从最大结点i

// 到根结点的路径检查最大结点，将x插入正确位置

for (int gp = i/4; gp&& (x.key > h[gp].key); gp /=4)
{ // gp是 i的祖父

h[i] = h[gp]; // 将h[gp]移到h[i]

i = gp;

}

h[i] = x; // 将x插入结点i

}

5. 删除最小节点

一般而言，将元素x插入根结点为空的最小最大堆h中有两种情况需要考虑：

（1） 根结点无子女，这时可将x插入根结点中。

（2） 根结点至少有一个子女。这时堆中的最小元素（不算元素x）位于根结点的子女结点或孙子女结点（最多6个）之一。

假设该结点的编号为k，则还需要考虑下列可能性：

(a) x.key≤h[k].key。由于h中不存在比x更小的元素，所以x可插入根。

(b) x.key > h[k].key且k是根的子女。由于k是最大结点，其后代的key值都不大于h[k].key，因而也不大于x.key。所以可将元素h[k]移到根，并将元素x插入结点k。

(c) x.key > h[k].key且k是根的孙子女。这时也可将元素h[k]移到根。设p是k的双亲。若x.key> h[p].key，则将x 和h[p]交换。这时，问题转化为将x插入以k为根的子堆中，且h[k]已腾空。这与初始插入根结点为空的最小最大堆h的情形类似。

template<class Type>

Element<Type>*MinMaxHeap<Type>:: DeleteMin(Element<Type>&y){ // 从最小最大堆中删除并返回最小元素

if (!n) { MinMaxEmpty( );return
0; }

y = h[1]; // 保存根元素

Element<Type> x = h[n--];

inti = 1, j = n/2; // 为重新插入x作初始化，寻找插入x的位置

while (i <= j) { // i 有子女，情况(2)

int k = MinChildGrandChild(i);

if (x.key <= h[k].key)

break; // 情况 2(a)，可将x 插入h[i]

else { //情况2(b)或 (c)

h[i] = h[k];

if (k <= 2*i+1) { // k 是i的子女，情况2(b)

i = k; // 可将x插入h[k]

break;

}

else { // k是i的孙子女，情况2(c)

int p = k/2; // p是k的双亲

if (x.key > h[p].key) {

Element<Type> t = h[p];h[p] = x; x = t;

}

} // if (k<=2*i+1)结束

i = k;

} //if (x.key<=h[k].key)结束

} // while结束

h[i] = x; // 注意，即使现在n == 0，对h[1] 赋值也没错，这样简化边界判断

return &y;

}

其中又用到私有成员函数MinChildGrandChild(i)，该函数返回结点i的子女结点或孙子女结点中含最小元素的结点。

如果i的子女结点或孙子女结点都含最小元素，则MinChildGrandChild返回子女结点，这样可以避免DeleteMin中while循环的进一步迭代。

分析：while循环的每次迭代需O(1)时间，且每经过一次迭代（可能除了最后一次以外），i都下移两层。由于n个元素的最小最大堆有O(logn)层，DeleteMin的时间复杂性是O(logn)。