BinaryHeap.h文件
#ifndef BINARY_HEAP_H
#define BINARY_HEAP_H
namespace ghost{
template<typename A>
void MinHeapShiftUp(A& array, const size_t size, size_t n/*umber(not index)*/)
{
if (0 == size)
{
// array为空
return;
}
if (size < n || 2 > n)
{
// n超出有效区间,或者没有父节点
return;
}
auto temp = array[n-1];
size_t holeN = n; // 建立空洞
while (true)
{
/// 测试父节点
size_t pn = holeN / 2; // 父节点number
if (0 == pn)
{
// pn超出有效区间
break;
}
if (array[pn-1] > temp)
{
// 父节点较大下移,将空洞移动到父节点位置
array[holeN-1] = array[pn-1];
holeN = pn;
}
else
{
// 已经找到位置
break;
}
}
if (holeN != n)
{
// 空洞位置发生变化,将节点放入空洞
array[holeN-1] = temp;
}
}
template<typename A>
void MinHeapShiftDown(A& array, const size_t size, size_t n/*umber(not index)*/)
{
if (0 == size)
{
// array为空
return;
}
if (size <= n || 0 == n)
{
// n超出有效区间,或者没有任何子节点
return;
}
auto temp = array[n-1];
size_t holeN = n; // 建立空洞
while (true)
{
/// 从空洞位置开始
size_t parentN = holeN;
auto* pMin = &temp;
/// 测试左子节点
size_t ln = 2 * parentN; // 左子节点number
if (size < ln)
{
// ln超出有效区间
break;
}
if (array[ln-1] < *pMin)
{
// 左子节点较小,将空洞移动到左子节点位置
holeN = ln;
pMin = &array[ln-1];
}
/// 测试右子节点
size_t rn = ln + 1; // 右子节点number
if (size >= rn)
{
if (array[rn-1] < *pMin)
{
// 右子节点较小,将空洞移动到右子节点位置
holeN = rn;
pMin = &array[rn-1];
}
}
if (holeN == parentN/*&temp == pMin*/)
{
// 已经找到位置
break;
}
else
{
// 较小节点上移
array[parentN-1] = /*array[holeN-1]*/*pMin;
}
}
if (holeN != n)
{
// 空洞位置发生变化,将节点放入空洞
array[holeN-1] = temp;
}
}
template<typename A>
void InitMinHeap(A& array, const size_t size)
{
for (size_t n = size/2; n > 0; --n)
{
MinHeapShiftDown(array, size, n);
}
}
} // namespace ghost
#endif // BINARY_HEAP_H
main.cpp文件
#include "FileDescriptor.h"
#include "ResizableBuffer.h"
#include "BinaryHeap.h"
#include <iostream>
#include <cassert>
template<typename A>
void PrintArray(A& array, const size_t size)
{
if (0 < size)
{
size_t endIndex = size - 1;
for (size_t i = 0; i < endIndex; ++i)
{
std::cout<<array[i]<<",";
}
std::cout<<array[endIndex];
}
std::cout<<std::endl;
}
int main()
{
std::cout<<"\n小根堆初始化:\n"<<std::endl;
int array[] = {9,8,7,6,5,4,3,2,1,0};
size_t arraySize = sizeof(array)/sizeof(array[0]);
PrintArray(array, arraySize);
ghost::InitMinHeap(array, arraySize);
std::cout<<"\n小根堆push模拟:\n"<<std::endl;
for (int i = 0; (size_t)i < arraySize; ++i)
{
/// 因为测试用数组定长,所以我利用每次改变数组最后一个元素的值来模拟push操作(push操作就是先将元素插入到末尾,然后上滤)
array[arraySize-1] = -(i);
PrintArray(array, arraySize);
ghost::MinHeapShiftUp(array, arraySize, arraySize);
std::cout<<"->";
PrintArray(array, arraySize);
}
std::cout<<"\n小根堆pop模拟:\n"<<std::endl;
for (int i = arraySize-1; i >= 0; --i)
{
/// 因为测试用数组定长,所以我利用每次将数组最后一个元素的值复制到数组头,然后将最后一个元素置0
///(pop操作就是先将数组头元素临时保存,然后将最后一个元素提道数组头,最后从数组头开始下滤)
PrintArray(array, arraySize);
array[0] = array[i];
array[i] = 0;
ghost::MinHeapShiftDown(array, i, 1);
std::cout<<"->";
PrintArray(array, i);
}
std::cin.get();
ghost::FileDescriptor testFD(0);
ghost::ResizableBuffer<int> testRB(1);
std::cout << "Hello world!" << std::endl;
return 0;
}