数据结构之堆，实现优先队列

如果最小值元素拥有最高的优先级，那么这种优先队列叫作升序优先队列（即总是先删除最小的元素），是最小堆。
反之，叫作降序优先队列。
降序优先队列：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DEFAULT_CAPACITY 128

typedef struct _Task
{
	int priority;		//降序优先队列
	//其他状态属性省略
}Task;

typedef Task DataType;
#define isLess(a,b) (a.priority < b.priority)

typedef struct _PriorityQueue
{
	DataType* arr;		//存储元素的数组
	int size;		//当前已存储元素的个数
	int capacity;	//当前存储的容量
}PriorityQueue;

//初始化
bool initPriorityQueue(PriorityQueue& pq, DataType* original, int size);
static void buildPriorityQueue(PriorityQueue& pq);
static void adjustDown(PriorityQueue& pq, int index);
//插入元素
bool push(PriorityQueue& pq, DataType value);
static void adjustUp(PriorityQueue& pq, int index);
//出列
bool pop(PriorityQueue& PriorityQueue, DataType& value);
//初始化任务
DataType& initTask(int priority);


bool initPriorityQueue(PriorityQueue& pq, DataType* original, int size)
{
	int capacity = DEFAULT_CAPACITY > size ? DEFAULT_CAPACITY : size;
	pq.arr = new DataType[capacity];
	if (!pq.arr) return false;
	pq.capacity = capacity;
	pq.size = 0;
	if (size > 0)
	{
		//方式1
		memcpy(pq.arr, original, sizeof(int)*size);
		pq.size = size;
		buildPriorityQueue(pq);

		//方式2
// 		for (int i=0; i<size; i++)
// 		{
// 			insertPriorityQueue(pq, original[i]);
// 		}
	}
	return true;
}

void buildPriorityQueue(PriorityQueue& pq)
{
	for (int i = pq.size/2 - 1; i >= 0; i--)
	{
		adjustDown(pq, i);
	}
}

void adjustDown(PriorityQueue& pq, int index)
{
	DataType cur = pq.arr[index];
	int parent, child;
	for (parent = index; (parent*2+1) < pq.size; parent = child)
	{
		child = parent * 2 + 1;
		if (child+1<pq.size && isLess(pq.arr[child], pq.arr[child + 1]))
		{
			child++;
		}
		if (isLess(pq.arr[child], cur))
		{
			break;
		}
		else 
		{
			pq.arr[parent] = pq.arr[child];
			pq.arr[child] = cur;
		}
	}
}

bool push(PriorityQueue& pq, DataType value)
{
	if (pq.size == pq.capacity) return false;
	int index = pq.size;
	pq.arr[pq.size++] = value;
	adjustUp(pq, index);
	return true;
}

void adjustUp(PriorityQueue& pq, int index)
{
	DataType cur = pq.arr[index];
	int child = index, parent = (child - 1) / 2;
	while (parent >= 0)
	{
		
		if (isLess(pq.arr[parent], cur))
		{
			pq.arr[child] = pq.arr[parent];
			pq.arr[parent] = cur;
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//删除最大的节点
bool pop(PriorityQueue& pq, DataType& value)
{
	if (pq.size < 1) return false;
	value = pq.arr[0];
	pq.arr[0] = pq.arr[--pq.size];
	adjustDown(pq, 0);//向下执行堆调整
	return true;
}

DataType& initTask(int priority)
{
	DataType* task = new DataType;
	task->priority = priority;
	return *task;
}

int main()
{
	PriorityQueue pq;
	DataType value;
	value.priority = 33;
	DataType origrinal[6];
	for (int i = 0; i < 6; i++)
	{
		int random = rand() % 50;
		origrinal[i] = initTask(random+20);
	}

	initPriorityQueue(pq, origrinal, 6);
	for (int i = 0; i < pq.size; i++)
	{
		printf_s("%d,",pq.arr[i].priority);
		
	}
	printf("\n");


	push(pq, value);
	for (int i = 0; i < pq.size; i++)
	{
		printf_s("%d,", pq.arr[i].priority);
	}
	printf("\n");

	//堆中元素出列,从大到小依次出列
	while (pop(pq, value))
	{
		printf("出列最大元素value:%d\n", value.priority);
	}

	system("pause");
	return 0;
}