二叉堆（最小堆）（数据结构与算法分析的代码实现）

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

“因为完全二叉树很有规律，所以可以用一个数组表示而不需要使用链”

上面两句是摘自《数据结构与算法分析》

书中代码的上滤和下滤的实现比算法导论的好，算法导论通过递归，每一次都交换不合适的节点，书本的代码则是通过循环找到节点正在要移动到的位置。

参考算法导论的代码：http://www.cnblogs.com/alan-forever/archive/2012/09/26/2704860.html

算法导论的是堆排序的代码，不过堆的性质都有的。

下面的代码是最小堆的，而且是一个类模板。

View Code

  1 #include<iostream>

  2 #include<vector>

  3 using namespace std;

  4 

  5 template <typename Comparable>

  6 class BinaryHeap

  7 {

  8 public:

  9     explicit BinaryHeap( int capacity = 100 ) : array( capacity + 10 )

 10     {

 11         currentSize = 0;

 12     }

 13 

 14     explicit BinaryHeap( const vector<Comparable> & item ) : array( item.size() + 10 ), currentSize( item.size() )

 15     {

 16         for(int i = 0; i < item.size(); ++i)

 17             array[i+1] = item[i];

 18         buildHeap();

 19     }

 20 

 21     bool isEmpty() const

 22     {

 23         return currentSize == 0;

 24     }

 25 

 26     const Comparable & finMin( ) const

 27     {

 28         return array[1];

 29     }

 30 

 31     void insert( const Comparable & x)

 32     {

 33         if(currentSize == array.size() - 1)

 34             array.resize( array.size() * 2);

 35 

 36         int hole = ++currentSize;

 37         for(; hole > 1 && x < array[hole / 2]; hole /= 2)

 38             array[hole] = array[hole / 2];

 39         array[hole] = x;

 40     }

 41 

 42     void deleteMin()

 43     {

 44         array[1] = array[currentSize--];

 45         percolateDowm( 1 );

 46     }

 47 

 48     void deleteMin(Comparable & Min)

 49     {

 50         Min = array[1];

 51         deleteMin();

 52     }

 53 

 54     void makeEmpty()

 55     {

 56         delete array[currentSize];

 57         currentSize = 0;

 58     }

 59 

 60     void print( )

 61     {

 62         for(int i = 1; i <= currentSize; ++i)

 63             cout << array[i] << " ";

 64         cout << endl;

 65     }

 66 

 67 private:

 68     int currentSize;

 69     vector<Comparable> array;

 70 

 71     void buildHeap()

 72     {

 73         for(int i = currentSize / 2; i > 0; i--)

 74             percolateDowm( i );

 75     }

 76 

 77     void percolateDowm( int hole )

 78     {

 79         int child;

 80         Comparable temp = array[hole];

 81 

 82         for(; hole * 2 <= currentSize; hole = child)

 83         {

 84             child = hole * 2;

 85             if(child != currentSize && array[child + 1] < array[child])

 86                 child++;

 87             if(array[child] < temp)

 88                 array[hole] = array[child];

 89             else

 90                 break;

 91         }

 92         array[hole] = temp;

 93     }

 94 };

 95 

 96 int main()

 97 {

 98     vector<int> a;

 99     int m;

100     for(int i = 0; i < 10; ++i)

101     {

102         cin >> m;

103         a.push_back( m );

104     }

105     BinaryHeap<int> minHeap( a );

106     cin >> m;

107     minHeap.insert( m );

108     minHeap.deleteMin();

109     minHeap.print();

110     return 0;

111 }