(堆排序和优先队列)heap.h

#ifndef HEAP_H
#define HEAP_H
#define DataType int
#define MAX 100
#define ADD 10
#define MAX_HEAP 1 //最大堆
#define MIN_HEAP 0 //最小堆

#include
#include
using namespace std;

void init_array( int N,DataType *Array ) //产生随机数
{
int i;
// Array = (DataType *)malloc(sizeof(DataType) * N);
srand( time(NULL) );
for( i = 0; i < N; i++ )
{
Array[i] = rand() ;
}
//free(Array);
}

void heapify(DataType *Array, int length, int i, int type) //调整最大（小）堆中i的位置
{
if (i < length)
{
int index = i;
if (i*2+1 < length) //i和左孩子比较
{
if (type == MAX_HEAP)
{
if (Array[index] < Array[i*2+1])
index = i*2+1;
}
else
{
if (Array[index] > Array[i*2+1])
index = i*2+1;
}
}
if (i*2+2 < length) //i和右孩子比较
{
if (type == MAX_HEAP)
{
if (Array[index] < Array[i*2+2])
index = i*2+2;
}
else
{
if (Array[index] > Array[i*2+2])
index = i*2+2;
}
}
if (index != i ) //i的位置改变了
{
DataType temp;

temp = Array[i];
Array[i] = Array[index];
Array[index] = temp; //i换到他相应的位置

heapify( Array, length, index, type); //新找到的点，进行递归 保证他的左右孩子的最值
}
}
}

void build_heap(DataType *Array, int length, int type) //建堆
{
int i;
for (i = length/2; i >= 0; i--) //注意第一个非叶子节点的序号
{
heapify(Array, length, i, type);
}
}

void heap_sort(DataType *Array, int length, int type) //堆排序
{
int i;
DataType tmp;

if (type == MAX_HEAP) //大到小
build_heap(Array, length, MAX_HEAP); //建大顶堆
else
build_heap(Array, length, MIN_HEAP); //建小顶堆

for (i = length - 1; i >= 1; i--)
{
tmp = Array[0];
Array[0] = Array[i];
Array[i] = tmp; //第一个和最后一个交换位置

if (type == MAX_HEAP)
heapify(Array, i, 0, MAX_HEAP);
else
heapify(Array, i, 0, MIN_HEAP);
}

}

class priority_queue //优先队列
{
public:
priority_queue();
void enqueue(DataType );
void dequeue(DataType *);
void print_queue();
void change_type(int );
friend void heapify(DataType, int, int, int); //友元函数，可以访问私有成员
private:
DataType *Array;
int size; //队列实际大小
int length; //队列空间大小
int type; //类型 1，最大堆 0，最小堆
};

priority_queue::priority_queue() //初始化优先队列
{
type = 0; //缺省为最小堆
size = 0;
length = MAX;
Array = (DataType*)calloc(MAX, sizeof(DataType));
}

int parent(int child) //寻找父节点下标
{
return (int)(child - 1)/2;
}

void priority_queue::enqueue(DataType data) //入队
{
if(size == length) //队列已满
{
Array = (int*)realloc(Array, (ADD + MAX) * sizeof(int));
length = length +

ADD;
} //重新分配空间
Array[size] = data;
int son_index = size;
int par_index = parent(size); //返回父节点的下标
size++;

if (type == MIN_HEAP)
{
while (par_index >= 0 && Array[son_index] < Array[par_index]) //父节点下标大于0 孩子小于父亲 则交换位置
{
DataType tmp = Array[son_index];
Array[son_index] = Array[par_index];
Array[par_index] = tmp; //交换位置

son_index = par_index;
par_index = parent(son_index);
}
}

if (type == MAX_HEAP)
{
while (par_index >= 0 && Array[son_index] > Array[par_index]) //父节点下标大于0 孩子大于父亲 则交换位置
{
DataType tmp = Array[son_index];
Array[son_index] = Array[par_index];
Array[par_index] = tmp;

son_index = par_index;
par_index = parent(son_index);
}
}
}

void priority_queue::dequeue(DataType *data) //出队
{
*data = Array[0]; //用指针返回出队的值
Array[0] = Array[size - 1];
size--;
if(type == MIN_HEAP) //长度减一 对0下标的值进行调整
heapify(Array, size, 0, MIN_HEAP);
if(type == MAX_HEAP)
heapify(Array, size, 0, MAX_HEAP);
}

void priority_queue::print_queue() //打印队列
{
for(int i = 0; i < size; i++)
cout<}

void priority_queue::change_type(int t) //改变优先队列的类型
{
type = t;

for (int i = size/2; i >= 0; i--) //注意第一个非叶子节点的序号
{
heapify(Array, size, i, type);
}
}
#endif

/*
#include "heap.h"

void main()
{
int i;
/*DataType Array[10] = {1,5,4,7,0,3,2,9,8,6};


init_array(n, Array);
heap_sort(Array, MAX, 1); //堆排序
DataType *Array;
int n = 5;
// Array = (DataType*)malloc(n * sizeof(DataType));

priority_queue queue;
queue.enqueue(3);
queue.enqueue(4);
queue.enqueue(5);
queue.enqueue(2);
queue.enqueue(9);
queue.print_queue();
queue.change_type(1);
queue.print_queue();
queue.dequeue(&i);
// queue.print_queue();

cout<cin>>i;
}*/