算法----优先队列

      队列：是一种满足先进先出（FIFO）的数据结构，数据从队列头部取出，新的数据从队列尾部插入，数据之间是平等的，不存在优先级的。

      优先队列：优先级队列有两种，最大优先级队列和最小优先级队列，这两种类别分别可以用最大堆和最小堆实现。

      优先队列支持的操作：

               INSERT(S,x)：把元素x插入到集合S

               MAXIMUM(S)：返回S中具有最大关键字的元素

               EXTRACT_MAX(S)：去掉并返回S中的具有最大关键字的元素

               INCREASE_KEY(S,x,k)：将元素x的关键字的值增加到k，这里k值不能小于x的原关键字的值。

最大优先级队列操作实现：

采用最大堆实现最大优先级队列，关于最大堆可以参见上一篇日志http://blog.youkuaiyun.com/chenxun_2010/article/details/48213197

（1）HEAP_MAXIMUM用O(1)时间实现MAXIMUM(S)操作，即返回最大堆第一个元素的值即可（return A[1])

（2）HEAP_EXTRACT_MAX实现EXTRACT_MAX操作，删除最大堆中第一个元素，然后调整堆

        操作过程如下：将最堆中最后一个元素复制到第一个位置，删除最后一个节点（将堆的大小减少1），然后从第一个节点位置开始调整堆，使得称为新的最大堆。操作过程如下图所示：

伪代码

[cpp]  view plain copy

1. HEAD_EXTRACT_MAX(A)  
2.  if heap_size[A]<1  
3.    ther error  
4.  max = A[1]  
5.  A[1] = A[heap_size[A]];  
6.  heap_size[A] = heap_size[A]-1  
7.  max_heapify(A,1)  
8.  return MAX  

（3）HEAP_INCREASE_KEY实现INCREASE_KEY，通过下标来标识要增加的元素的优先级key，增加元素后需要调整堆，从该节点的父节点开始自顶向上调整。操作过程如下图所示：

伪代码：

[cpp]  view plain copy

1. HEAP_INCREASE_KEY(A,i,key)  
2.    if key < A[i]  
3.      then error  
4.    A[i] = key  
5.   while i>1 && A[PARENT(i)] <A[i]  
6.        do exchange A[i] <-> A[PARENT(i)]  
7.        i = PARENT(i)  

（4）MAX_HEAP_INSERT实现INSERT操作，向最大堆中插入新的关键字。新的关键字插入在优先级的队尾部，然后从尾部的父节点开始自顶向上调整堆伪代码描述如下：

MAX_HEAP_INSERT(A, key)
	A.heap_size = A.heap_size + 1
	A[A.heap_size] = -0;
	HEAP_INCREASE_KEY(A, A.heap_size, key)

最后总结一下完成操作代码：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

void swap(int *x, int *y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//建立以root为i(即根节点为i)的最大堆，利用了递归的思想防止调整之后以largest为父节点的子树不是最大堆
void max_heapify(vector<int> &a, int i, int heapsize)
{
	int l = 2 * i;//取其左孩子的坐标
	int r = 2 * i + 1;//取其右孩子的坐标
	int largest;//临时变量，用来保存r、l、r三个节点中最大的值

	if (l <= heapsize&&a[l]>a[i])
		largest = l;
	else
		largest = i;

	if (r <= heapsize&&a[r]>a[largest])
		largest = r;

	if (largest != i)
	{
		swap(&a[i], &a[largest]);
		max_heapify(a, largest, heapsize);
	}
}

//***********************************************
//用自底向上的方法把数组转换成最大堆  
void buil_max_heap(vector<int> &a, int heapsize)
{
	int i;

	//从heapsize/2+1到heapsize的节点都是叶节点，所以我们可以把他们都看成是包含一个元素的最大堆了
	//所以从数组1到heapsize的有叶节点的节点建立最大堆
	for (i = heapsize / 2; i >= 1; i--)
	{
		max_heapify(a, i, heapsize);
	}
}

//1.返回堆中最大关键字的元素
int heap_max_inum(vector<int> a)
{
	return a[1];
}

//2.去掉堆中并返回堆中最大关键字的元素
int heap_extract_max(vector<int> &a, int &heapsize)
{
	if (heapsize < 1)
		cout << "there is no data in data" << endl;

	int max = a[1];
	a[1] = a[heapsize];
	heapsize--;
	a.pop_back();
	max_heapify(a, 1, heapsize);
	return max;
}

//3.将第i个元素的值增加到key
void heap_increase_key(vector<int> &a, int i, int key)
{
	if (key < a[i])
		cout << " error: new key is smaller than current key" << endl;
	int p = i / 2;
	a[i] = key;
	while (i>1 && a[i] > a[p])
	{
		swap(a[i], a[p]);
		i = p;
		p = i / 2;
	}
}

//4.将元素插入到集合中去。
void max_heap_insert(vector<int> &a, int key, int &heapsize)
{
	heapsize++;
	a.push_back(INT_MIN);
	//a[heapsize] = INT_MIN;//给一个最小的负数，符合调用heap_increase_key
	heap_increase_key(a, heapsize, key);
}

int main()
{

	vector<int> a = { 0, 12, -3, 88, 52, 6, 4, 33, 2, 100, 5 };
	int heapsize = a.size() - 1;
	cout << heapsize << endl;

	buil_max_heap(a, heapsize);
	for (auto i : a)
		cout << i << " ";
	cout << endl;

	for (int i = 0; i < 10; ++i)
	{
		cout << heap_extract_max(a, heapsize) << endl;
		for (auto i : a)
			cout << i << " ";
		cout << endl;
	}

	cout << heapsize << endl;

	heap_increase_key(a, heapsize, 11);
	for (auto i : a)
		cout << i << " ";
	cout << endl;

	max_heap_insert(a, 55, heapsize);
	for (auto i : a)
		cout << i << " ";
	cout << endl;

	return 0;
}