大根堆的pop&remove&initialize
1. 定义
- [max(min) tree] 一棵树, 其中每个节点的值都大于 (小于) 或等于其 children (如果有) 的值.
- [max(min) heap] max(min) tree + complete binary tree.
2. 性质
- heap 是一种 隐式数据结构 (implicit data structure).
用 完全二叉树 表示的 heap 在数组中 隐式储存 (没有明确的指针或其他数据能够用来重塑这种结构).
由于没有储存 结构信息, 这种表示方法的空间利用率很高 (没有浪费任何空间); 又由于用数组形式储存, 它的时间效率也很高. - 由于是 完全二叉树, 自然满足如下性质:
- 若一颗 complete binary tree 有 \(n\) 个元素, 那么它的高度为 \(\log_2 (n+1)\) .
- 设一颗 complete binary tree 中一元素的编号为 \(i\) , \(1 \leq i \leq n\) , 则有以下关系:
- 若 \(i = 1\) , 则该元素为二叉树的 root; 若 \(i>1\) , 则其 parent 的编号为 \(\lceil i/2 \rceil\) .
- 若 \(2i>n\) , 则该元素无 left child; 否则, 其 left child 的编号为 \(2i\) .
- 若 \(2i+1>n\) , 则该元素无 right child; 否则, 其 right child 的编号为 \(2i+1\) .
3. 大根堆的 pop & remove
3.1. 核心逻辑 & 发现问题
不失一般性, 存在如下图一个大根堆.
假设现在要删除 heap[current]
, 那么我们要做的核心步骤是:
- 将
heap[current]
的 children 中较大的那个 (我们假设那个结点是heap[child]
) 移动到heap[current]
的位置;
这时 heap[child]
相当于 "空" 的状态,
因此顺理成章地利用递归或迭代, 再把 heap[child]
当作新的 heap[current]
而反复执行核心步骤.
应当将 child
小于 heapSize
作为限制 iteration 或 recursion 继续进行的条件.
然而, 如果我们使用上述逻辑 pop 上图中的 heap[1]
:
- 48 填入
heap[1]
; - 43 填入
heap[2]
; - 30 填入
heap[4]
; heap[8]
为空;
为满足 定义 1 和 定义 2, 此时若将 lastElement = 41
填入 heap[8]
, 则 heap[4] = 30
小于 heap[8] = 41
, 与 定义 1 产生冲突.
为什么会出现这样的问题呢?
根据 定义 1:
[max(min) tree] 一棵树, 其中每个结点的值都大于(小于)或等于其 children (如果有)的值.
我们应该明确一点:
- 整体上, 大根树中下层元素不一定大于上层元素, 而只是每个结点要大于自己所有的 descendent.
如上图, 尽管 heap[11]
在 level 4; 但仍比处于 level 2 的 heap[3]
大.
这就是为什么在 pop 或者 remove 时, 我们需要更加复杂的方法进行 重构.
3.2. 重构大根堆
2.1. 提出的问题不建议使用 recursion 解决; 因为如果用 iteration, 只要在循环体中添加一步简单的判断就即可.
再次观察前文的大根堆:
我们发现, 冲突的产生本质上是因为,
尽管 heap[4]
是 silblings 中较大的那个, 但它的 child heap[8]
并没有其 sibling (也就是 heap[5]
) 的 child heap[11] = lastElement
大.
那么, 我们只要在保持核心逻辑的同时, 一旦发现 heap[current]
的较大 child 比 lastElement
小, 那就结束循环, 把 lastElement
填入 heap[current]
! 后面的就不用管了!
如果没找到......那就继续循环, 循环到底, 把 lastElement
填到最下面就好.
3.3. 代码实现
- pop最顶端元素(root).
template<class T>
void maxHeap<T>::pop() {
if (heapSize == 0) throw queueEmpty();
// Delete the largest element.
heap[1].~T();
// Delete the last element and re-construct the heap.
T lastElement = heap[heapSize];
heap[heapSize--].~T();
// Starting from the root, find location for the last element.
int current = 1,
child = 2;
// Loop until the end.
while (child <= heapSize) {
// "child" should be the larger child of "current"
if (child < heapSize && heap[child] < heap[child + 1]) { child++; }
// IF: "current" points to a node whose child is smaller than "lastElement",
// indicating that "lastElement" can be put in "heap[current]".
if (lastElement >= heap[child]) {
// End loop.
break;
}
// OTHERWISE.
else {
heap[current] = heap[child];
current = child;
// Move "child" to its child.
child << 1;
}
}
heap[current] = lastElement;
}
- remove下标为 i 的元素.
template<class T>
T maxHeap<T>::remove(int i) {
if (heapSize == 0) throw queueEmpty;
T theDeleted = heap[i];
T lastElement = heap[heapSize];
heap[heapSize].~T();
int current = i, child = i << 1;
while (child <= heapSize) {
// Make sure "child" points to the larger one between the sublings.
if (child < heapSize && heap[child] < heap[child + 1]) {
child++;
}
// IF: "current" points to a node whose child is smaller than "lastElement",
// indicating that "lastElement" can be put in "heap[current]".
if (lastElement >= heap[child]) {
// End loop.
break;
}
// OTHERWISE.
else {
heap[current] = heap[child];
current = child;
child <<= 1;
}
}
heap[current] = lastElement;
return theDeleted;
}
3.4. 复杂度分析
对于方法 pop
, 遍历只迭代至 left/right child, 因此时间复杂度为:
方法 remove
的复杂度取决于目标 node 的 descendent 的数量.
4. Initialize
4.1. 逻辑分析
root
从最后一个 node 的 parent node 开始向根迭代, 直至 max heap 真正的根;
对于迭代中的每个 root
, child
从其 child node 开始向 descendent 迭代 (迭代需要保证 child
指向 siblings 中较大的那个):
- 若
rootElement
小于child
的元素, 则child
继续向 descendent 迭代, 同时将child
的元素覆盖至child/2
; - 若
rootElement
大于等于child
的元素, 则child
终止迭代, 同时将rootElement
存入child/2
;
4.2. 代码实现
template<class T>
void maxHeap<T>::initialize(T* theHeap, int theSize)
{
delete[] heap; // Empty the memory of "T* maxHeap<T>::heap".
heap = theHeap; // Make "heap" points to "theHeap".
heapSize = theSize; // Set the "heapSize".
// 'root' would iterates from {heapSize/2 (parent of the last element)} and keep decreasing until reaches real root.
for (int root = heapSize / 2; root >= 1; root--) {
// Pick up the current element of 'root'.
T rootElement = heap[root];
int child = 2 * root;
// 'child' iterates from the child of current root to end, but cannot be larger than 'heapSize'.
for (; child <= heapSize; child *= 2) {
// Ensure 'heap[child]' is the larger one between the siblings.
if (child < heapSize && heap[child] < heap[child + 1]) { child++; }
if (rootElement >= heap[child]) { // IF: 'rootElement' can be put in 'heap[child/2]'.
break;
}
// IF: "rootElement" cannot be put in "heap[child/2]".
// Move 'heap[child]' to 'heap[child/2]'.
heap[child/2] = heap[child];
// Re-allocate the next level to 'child'.
}
heap[child / 2] = rootElement;
}
}
4.3. Complexity
假设元素个数为 \(n\), 高度为 \(h\).
- 由于外层 for 循环
root
从 \(n/2\) 开始迭代, 因此从元素上看总共迭代了 \(n/2\) 次, 从层数上看总共迭代了 \(h-1\) 层. - 内层 for 循环的每次迭代, 实际上都遍历了一棵 complete binary tree, 复杂度为 \(O(h_{i})\). 其中 \(h_{i}\) 是该层 complete binary tree 的高度.
- binary tree 的第 \(j\) 层, 最多有 \(2^{j-1}\) 个 node; 而每个 node 的高度 \(h_{i}=h-j+1\).
因为有 \(n\) 个元素的 complete binary tree 的高度为 \(h= \lceil \log_{2}{(n+1)} \rceil\), 因此:
由于外层 for 循环从元素上看迭代了 \(n/2\) 次, 所以复杂度下限为 \(\Omega(n)\).
综上, 方法 initialize
的复杂度为:
Reference | Data Structures, Algoritms, and Applications in C++, Sartaj Sahni