BinaryHeap 的C++实现

       堆是一棵被完全填满的二叉树，底层上的元素从左到右填入，这样的树称为完全二叉树。

一棵高为h的完全二叉树右2^h到2^(h+1) - 1 个结点。完全二叉树的树高为logN。

                    A

               /         \

           B            C

       /       \        /      \

     D        E      F      G

  /      \       /

H        I    J

_________________________________________________

|_ _| _A_ |_B_|_C_|_D_|_E_|_F_|_G_|_H_|_I_|_J_|_ _|_ _|_ _|

   0      1      2      3     4      5     6     7      8     9    10   11   12   13

      对于数组中任意位置 i 上的元素，其左儿子在位置2i上，右儿子在（2i + 1）上。它的父亲则在[i / 2] 上。

一个堆数据结构由一个数组和一个表示当前大小的证书组成。

下面的实现代码分为 BinaryHeap.h 和 main.cpp.

模板编程分文件写编译器支持不一，所以一般在一个文件内实现。

BinaryHeap.h

#ifndef __BINARY_HEAP_H
#define __BINARY_HEAP_H

#include <iostream>
#include <vector>
#include <exception>
#include <cstdlib>
using std::vector;
using std::cout;
using std::endl;
using namespace std;

class UnderflowException : public exception
{
public :
UnderflowException() : exception()
{
cout << "underflow\n";
exit(0);
}
};

template <typename T>
class BinaryHeap
{
public:
explicit BinaryHeap(int capacity = 100);
explicit BinaryHeap(const vector<T> & items);
~BinaryHeap();

bool isEmpty() const;
const T & findMin() const;

void insert(const T &x);
void deleteMin();
void deleteMin(T & minItem);
void makeEmpty();
T  minimum() const;
void print() const;
private:
int       currentSize;    // number of elements in heap
vector<T> array;          // the heap array

void buildHeap();
void percolateDown(int hole);
};

template <typename T>
BinaryHeap<T>::BinaryHeap(int capacity)
: array(capacity + 10)
{
currentSize = 0;
}

template <typename T>
BinaryHeap<T>::BinaryHeap(const vector<T> & item)
: array(item.size() + 10), currentSize(item.size())
{
for(int i = 0; i < item.size(); ++i)
{
array[i+1] = item[i];
}
buildHeap();
}

template <typename T>
BinaryHeap<T>::~BinaryHeap()
{
makeEmpty();
//	(array).swap(array);  // 匿名对象，来释放空间
array.shrink_to_fit(); // -std=c++11
cout << "array.capacity() " << array.capacity() <<endl;
cout << "~BinaryHeap()" << endl;
}

/**
*  Establish heap order property from an arbitrary arrangement of items.
*  Runs in linear time. O(n)
*/
template <typename T>
void BinaryHeap<T>::buildHeap()
{
for(int i = currentSize / 2; i > 0; --i)
percolateDown(i);
}

template <typename T>
void BinaryHeap<T>::makeEmpty()
{
currentSize = 0;
array.clear();
}

template <typename T>
T BinaryHeap<T>::minimum() const
{
if(isEmpty())
throw UnderflowException();

return array[1];
}

template <typename T>
void BinaryHeap<T>::print() const
{
for(int i = 1 ; i <= currentSize; ++i)
cout << array[i] << " ";
cout << endl;
}

template <typename T>
inline bool BinaryHeap<T>::isEmpty() const
{
return currentSize == 0;
}

/*
* Insert item x, allowing duplicates
*/
template <typename T>
void BinaryHeap<T>::insert(const T &x)
{
if(currentSize == array.size() - 1)
{
array.resize(array.size() * 2);
}
int hole = ++currentSize;
for( ; hole > 1 && x < array[hole / 2]; hole /= 2)
{
array[hole] = array[hole / 2];
}
array[hole] = x;
}

/*
* Remove the minimum item.
* Throws UnderflowException if empty.
*/
template <typename T>
void BinaryHeap<T>::deleteMin()
{
if(isEmpty())
throw UnderflowException();

array[1] = array[currentSize--];
percolateDown(1);
}

/*
* Remove the minimum item and place it in minItem.
* Throws UnderflowException if empty.
*/
template <typename T>
void BinaryHeap<T>::deleteMin(T & minItem)
{
if(isEmpty)
throw UnderflowException();

minItem = array[1];
array[1] = array[currentSize--];
percolateDown(1);
}

template <typename T>
void BinaryHeap<T>::percolateDown(int hole)
{
int child;
T tmp = array[hole];

for( ; (hole << 2) <= currentSize; hole = child)
{
child = hole << 2; // hole * 2
if(child != currentSize && array[child + 1] < array[child])
child++;
if(array[child] < tmp)
array[hole] = array[child];
else
break;
}
array[hole] = tmp;
}

#endif // #ifndef __BINARY_HEAP_H

main.cpp

#include <iostream>

#include "BinaryHeap.h"

using namespace std;

int main(int argc, char **argv)
{
BinaryHeap<int> bHeap;
cout << (bHeap.isEmpty() ? "empty" : "not empty") << endl;
//bHeap.deleteMin(); // exception: the Heap is empty
bHeap.insert(10);
bHeap.insert(2);
bHeap.insert(5);
bHeap.insert(13);
bHeap.insert(1);
bHeap.insert(8);

cout << "minimum  " << bHeap.minimum() << endl;
bHeap.print();

bHeap.deleteMin();
bHeap.print();

BinaryHeap<int> bHeap2(bHeap);
cout << "bHeap2" << endl << "	";
bHeap2.print();

return 0;
}

makefile非常非常简单，

# 2015-11-15
# Summer

#object = main.o

main :
g++ -std=c++11 main.cpp -o main

#main.o: BinaryHeap.h
#g++ -std=c++11 -c main.o main.cpp BinaryHeap.h

.PHONY: clean
clean:
rm -rf $(object)
cleanAll:
rm -r main $(object)

不想写mekefile也可以的，编译时输入

g++ -std=c++11 main.cpp -o main

即可

输出内容：

empty
minimum  1
1 2 5 13 10 8
8 2 5 13 10
bHeap2
8 2 5 13 10
array.capacity() 0
~BinaryHeap()
array.capacity() 0
~BinaryHeap()

以上内容参考《数据结构与算法分析C++描述》。