优先队列的详解与应用

优先队列的定义：优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找;2) 插入一个新元素;3) 删除.在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.

个人认为，优先队列是一种特殊的队列，每个元素被赋予优先权，当访问队列元素师，具有最高优先权的元素先被访问。也就是largest-in，first-out。

优先队列的时间复杂度为O(logn);

首先附上百度百科的优先队列类定义：

#include<iostream>
#include<stdlib.h>
const int maxPQSize = 50;//缺省元素个数
template<classType>classPQueue
{
public:
	PQueue();
	~PQueue() { delete[]pqelements; }
	voidPQInsert(constType&item);
	TypePQRemove();
	voidmakeEmpty() { count = 0; }
	intIsEmpty()const
	{
		returncount == 0;
	}
	intIsFull()const
	{
		returncount == maxPQSize;
	}
	intLength()const { returncount; }
private:
	Type*pqelements;//存放数组
	int count;//队列元素计数
}

后来自己在网上看了一些大神的博客，仿照人家的代码练习了一些，贴上代码：

#include<stdio.h> 
#include<iostream> 
#include<string> 
#include<string.h> 
#include<algorithm> 
#include<vector> 
#include<time.h> 
#include<queue> 
#include<stack> 
#include<iterator> 
#include<math.h> 
#include<stdlib.h> 
#include<limits.h> 
#include<map> 
#include<memory.h> 
//#define ONLINE_JUDGE 
#define eps 1e-8 
#define INF 0x7fffffff                                          //INT_MAX 
#define inf 0x3f3f3f3f                                          //int?????????????????? 
#define FOR(i,a) for((i)=0;i<(a);(i)++)                          //[i,a); 
#define MEM(a) (memset((a),0,sizeof(a))) 
#define sfs(a) scanf("%s",a) 
#define sf(a) scanf("%d",&a) 
#define sfI(a) scanf("%I64d",&a) 
#define pf(a) printf("%d\n",a) 
#define pfI(a) printf("%I64d\n",a) 
#define pfs(a) printf("%s\n",a) 
#define sfd(a,b) scanf("%d%d",&a,&b) 
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c) 
#define for1(i,a,b) for(int i=(a);i<b;i++) 
#define for2(i,a,b) for(int i=(a);i<=b;i++) 
#define for3(i,a,b)for(int i=(b);i>=a;i--) 
#define MEM1(a) memset(a,0,sizeof(a)) 
#define MEM2(a) memset(a,-1,sizeof(a)) 
#define LL __int64 
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {
	return b ? gcd(b, a % b) : a;
}
template<class T> T lcm(T a, T b) {
	return a / gcd(a, b) * b;
}
template<class T> inline T Min(T a, T b) {
	return a < b ? a : b;
}
template<class T> inline T Max(T a, T b) {
	return a > b ? a : b;
}
using namespace std;
template<class T>
T Mint(T a, T b, T c) {
	if (a > b) {
		if (c > b)
			return b;
		return c;
	}
	if (c > a)
		return a;
	return c;
}
template<class T>
T Maxt(T a, T b, T c) {
	if (a > b) {
		if (c > a)
			return c;
		return a;
	} else if (c > b)
		return c;
	return b;
}

struct cmp1{
	bool operator()(int &a,int &b){
		return a>b;
	}
};

struct cmp2{
	bool operator()(int &a,int &b){
		return a<b;
	}
};

struct num1{
	int x;
	bool operator<(const num1 &a) const{
		return x>a.x;
	}
};

struct num2{
	int x;
	bool operator<(const num2 &a) const{
		return x<a.x;
	}
};

int a[]={14,10,56,7,83,22,36,91,3,47,72,0};
num1 nu1[]={14,10,56,7,83,22,36,91,3,47,72,0};
num2 nu2[]={14,10,56,7,83,22,36,91,3,47,72,0};

int main() {
#ifndef ONLINE_JUDGE
	//    freopen("in.txt","r",stdin);
	//    freopen("out.txt","w",stdout);
#endif
	priority_queue<int>que;

	priority_queue<int,vector<int>,cmp1>que1;
	priority_queue<int,vector<int>,cmp2>que2;

	priority_queue<int,vector<int>,greater<int> >que3;
	priority_queue<int,vector<int>,less<int> >que4;

	priority_queue<num1>que5;
	priority_queue<num2>que6;

	for(int i=0;a[i];i++){
		que.push(a[i]);
		que1.push(a[i]);
		que2.push(a[i]);
		que3.push(a[i]);
		que4.push(a[i]);
	}
	for(int i=0;nu1[i].x;i++)
		que5.push(nu1[i]);
	for(int i=0;nu2[i].x;i++)
		que6.push(nu2[i]);

	printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que)\n");

	printf("Queue 1:\n");
	while(!que1.empty()){
		printf("%3d",que1.top());
		que1.pop();
	}
	putchar(10);

	printf("Queue 2:\n");
	while(!que2.empty()){
		printf("%3d",que2.top());
		que2.pop();
	}
	putchar(10);

	printf("采用头文件\"functional\"内定义优先级:\n(priority_queue<int,vector<int>,greater<int>/less<int>>que;)\n");

	printf("Queue 3:\n");
	while(!que3.empty()){
		printf("%3d",que3.top());
		que3.pop();
	}
	putchar(10);

	printf("Queue 4:\n");
	while(!que4.empty()){
		printf("%3d",que4.top());
		que4.pop();
	}
	putchar(10);

	printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");

	printf("Queue 5:\n");
	while(!que5.empty()){
		printf("%3d",que5.top());
		que5.pop();
	}
	putchar(10);

	printf("Queue 6:\n");
	while(!que6.empty()){
		printf("%3d",que6.top());
		que6.pop();
	}
	putchar(10);

	return 0;
}

最后，附上一道题目，一开始做这题一直TML，后来看到大神用了优先队列的方法，觉得很巧妙（是我太无知，当时还不会用优先队列= =！）

输出数字[蓝]

时间限制(C/C++):1000MS/3000MS          运行内存限制:65536KByte
总提交:109            测试通过:29

描述

    给定m以及n个数，这n个数每个数字的大小都在[0, 100000]之间。你需要输出每m个数中的最大数。即1到m中的最大数，2到m+1中的最大数......一直到n-m+1到n中的最大数。比如对于m=3，n=6，六个数字为1 2 3 3 4 1时，前三个数字1 2 3最大是3，然后接下来三个数字2 3 3最大是3，接下来3 3 4最大是4，接下来3 4 1最大是4。所以需要输出3 3 4 4。

输入

输入数据有多组。每组数据第一行是m和n，2<=m<=n<=7000.接下来一行有n个数字，每个数字范围在[0,100000]之间。m=n=0输入结束。

输出

对于每组数据，输出n-m+1个数字，代表每m个数字之间的最大数。输出见样例，注意每个输出的数字后都有一个空格。

样例输入

3 6
1 2 3 3 4 1
3 10
10 11 10 0 0 0 1 2 3 2
0 0

样例输出

3 3 4 4 
11 11 10 0 1 2 3 3 

题解：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
 
struct node
{ 
    int x;
    int id;
    bool operator<(const node &a)const
    {
        return x<a.x;
    }
}tmp;
 
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        if(m==0&&n==0)
            break;
        priority_queue<node> q;
        for(int i=0;i<n;i++)
        {
            scanf("%d",&tmp.x);
            tmp.id=i;
            q.push(tmp);
        }
        tmp=q.top();
        cout<<tmp.x<<" ";
        for(int i=n;i<m;i++)
        {
            scanf("%d",&tmp.x);
            tmp.id=i;
            while(q.top().id<=i-n)
                q.pop();
            q.push(tmp);
            tmp=q.top();
            cout<<tmp.x<<" ";
        }
        putchar(10);
    }
    return 0;
}