最小堆，堆排序(c++代码)

//所谓的最大堆,最小堆其实是一颗完全二叉树.并以数组来存储树的节点元素.这里的示例从数组的0下标开始存储树的节点.
//最小堆的父节点<=子节点,最大堆的父节点>=子节点.
//最大堆常用于实现优先队列等,最小堆常用于实现定时器(例如libevent)等.
//以下代码实现了最小堆和堆排序的算法,作为备忘笔记.使用的时候可以封装成模板类,这里只是算法的示例代码.
//从大到小排序使用最小堆,从小到大排序使用最大堆.
//要改成最大堆只需要改几个(<=)运算符.
//如有错误,欢迎指正.

#include <stdlib.h>
#include <stdio.h>
#include <vector>
#define HEAP_PARENT(i)		((i-1)/2)
#define HEAP_LEFTCHILD(i)	(2*i+1)
#define HEAP_RIGHTCHILD(i)	(2*i+2)

using namespace std;

//节点
struct HeapNode{
HeapNode(int k) : key(k){}
int key;
};

//
struct Heap{
Heap():size_(0) {}
vector<HeapNode*>	vec_;
int                 size_;
};

//下移pos位置节点.
//如果pos位置的节点 > 其子节点,则将pos位置元素和其子节点中较小的节点交换.并重复此过程,直到不能再下移.
void shiftDown( Heap & h , int pos ) {
int last_index = h.size_ - 1;
while (1){
//叶节点,下移结束
bool has_child = HEAP_LEFTCHILD(pos) <= last_index ? true : false;
if ( !has_child ) break;
//找到父子三个节点中最小节点的位置
int min_index;
min_index = h.vec_[pos]->key <= h.vec_[HEAP_LEFTCHILD(pos)]->key ? pos : HEAP_LEFTCHILD(pos);
bool has_right_child = HEAP_RIGHTCHILD(pos) <= last_index ? true : false;
if (has_right_child){
min_index = h.vec_[min_index]->key <= h.vec_[HEAP_RIGHTCHILD(pos)]->key ? min_index : HEAP_RIGHTCHILD(pos);
}
//如果父节点不是最小则和最小的子节点交换位置
if ( pos == min_index) break;
//交换节点数据,更新pos,进行下一轮下移.
HeapNode * temp = h.vec_[ pos ];
h.vec_[ pos ] = h.vec_[ min_index ];
h.vec_[ min_index ] = temp;
pos = min_index;
}
}

//上移pos位置节点.
//如果pos位置的节点小于父节点,则和父节点交换.并重复此过程,直到不能再上移.
void shiftUp( Heap & h , int pos ){
while ( pos > 0) {
int parent = HEAP_PARENT(pos);
if ( h.vec_[parent]->key <= h.vec_[pos]->key) break;
//
HeapNode * temp = h.vec_[pos];
h.vec_[pos] = h.vec_[parent];
h.vec_[parent] = temp;
pos = parent;
}
}

//将新节点加入到最后,并且上移该节点到适当位置.
void push( Heap & h , HeapNode * newNode ){
int pos = h.size_;
h.vec_.push_back(newNode);
h.size_++;
shiftUp(h , pos);
}

//将第一个节点与最后一个节点交换,再删除最后一个节点,从而弹出树顶端的节点.
//将交换后的第一个节点下移到适当位置.
HeapNode * pop(Heap & h){
if ( h.size_ == 0 ) return NULL;
HeapNode * res = h.vec_[0];
h.vec_[0] = h.vec_[ h.size_ - 1 ];
h.vec_.pop_back();
h.size_--;
shiftDown( h , 0 );
return res;
}

//建堆
//从最后一个非叶子节点开始下移.直到根节点下移.将无序的数组创建为一个最小堆.
void makeHeap(Heap & h){
for (int i = h.size_/2 - 1 ; i >= 0 ; i--){
shiftDown(h , i);
}
}

//堆排序
//由于最小堆的树顶元素为最小值,将树顶元素与最后一个元素交换,并且减小堆的大小.然后维护堆的性质.
//等到树中只剩下一个元素的时候,存储堆的数组就是一个有序的序列.
void heapSort(Heap & h){
for( int i = h.size_ - 1 ; i>=1 ; i-- ){
//
HeapNode * temp = h.vec_[i];
h.vec_[i] = h.vec_[0];
h.vec_[0] = temp;
h.size_--;
//
shiftDown(h , 0);
}
}

void print_vec( Heap & h ){
for (int i = 0 ; i < h.vec_.size() ; i++){
printf("%d " , h.vec_[i]->key);
}
}

#if 0
int main(){
Heap h;
HeapNode * node;
printf("\n=====push , pop=======\n");
push(h , new HeapNode(100) );
push(h , new HeapNode(88) );
push(h , new HeapNode(89) );
push(h , new HeapNode(111) );
push(h , new HeapNode(60) );
while( (node = pop(h)) != NULL ){
printf( "%d " , node->key );
}
printf("\n=====make heap , pop=======\n");
h.vec_.push_back( new HeapNode(100) );
h.vec_.push_back( new HeapNode(88) );
h.vec_.push_back( new HeapNode(89) );
h.vec_.push_back( new HeapNode(111) );
h.vec_.push_back( new HeapNode(60) );
h.size_ = 5;
makeHeap(h);
while( (node = pop(h)) != NULL ){
printf( "%d " , node->key );
}
printf("\n=====make heap , heap sort=======\n");
h.vec_.push_back( new HeapNode(100) );
h.vec_.push_back( new HeapNode(88) );
h.vec_.push_back( new HeapNode(89) );
h.vec_.push_back( new HeapNode(111) );
h.vec_.push_back( new HeapNode(60) );
h.size_ = 5;
makeHeap(h);
heapSort(h);
print_vec(h);

}
#endif