优先队列

/*栈*/ 
#include<stack>
stack<int> st;
st.empty();
st.size();//返回栈中的元素的个数.
st.pop();
st.push();
st.top();

/*队列*/
#include<queue>
queue<int>q;
q.empty();
q.size();//返回队列中元素的个数.
q.pop();
q.front();//返回队首的位置
q.back();//返回队尾的位置
q.push();

/*优先队列：普通的队列先进先出，队尾进，队头出。而优先队列中，元素被赋予优先级，当访问元素时，具有最高优先级的元素最先取出。*/
#include<queue>
q.empty();
q.size();
q.pop();//删除队首元素
q.push(item);//基于优先级，插入新元素
q.top();//返回具有最高优先级的元素

 

 

//下面是优先队列的基本使用，（&可以省略）
#include<queue>
#include<functional>
#include<vector>
using namespace std;
//定义比较结构，使用运算符重载，自定义优先级1
struct cmp1
{
	bool operator()(int &a,int &b)
	{
		return a>b;//最少值优先.
	}
}; 
struct cmp2
{
	bool operator()(int &a,int &b)
	{
		return a<b;//最大值优先. 
	}
}; 
//定义结构，使用运算符重载，自定义优先级2 
struct number1  
{  
    int x;  
    bool operator<(const number1 &a) const  
    {  
        return x>a.x;//最小值优先  
    }  
};  
struct number2  
{  
    int x;  
    bool operator<(const number2 &a) const  
    {  
        return x<a.x;//最大值优先  
    }  
}; 
int a[]= {14,10,56,7,83,22,36,91,3,47,72,0};  
number1 num1[]= {14,10,56,7,83,22,36,91,3,47,72,0};  
number2 num2[]= {14,10,56,7,83,22,36,91,3,47,72,0};  
  
int main()  
{  
    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<number1>que5; //最小优先级队列  
    priority_queue<number2>que6;  //最大优先级队列  
  
    int i;  
    for(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(i=0; num1[i].x; i++)  
        que5.push(num1[i]);  
    for(i=0; num2[i].x; i++)  
        que6.push(num2[i]);  
    //默认，则是从大到小排序，91 83 72 56 47 36 22 14 10  7  3 ，91是头部。
    while(!que.empty())  
    {  
        printf("%3d",que.top());  
        que.pop();  
    }   
	//priority_queue<int,vector<int>,cmp1>que1;最小值优先 
    while(!que1.empty())  
    {  
        printf("%3d",que1.top());  
        que1.pop();  
    } //3  7 10 14 22 36 47 56 72 83 91
	//priority_queue<int,vector<int>,cmp2>que2;//最大值优先 
    while(!que2.empty())  
    {  
        printf("%3d",que2.top());  
        que2.pop();  
    }  
	//priority_queue<int,vector<int>,greater<int> >que3;最小值优先
    while(!que3.empty())  
    {  
        printf("%3d",que3.top());  
        que3.pop();  
    }  // 3  7 10 14 22 36 47 56 72 83 91
     
    //priority_queue<int,vector<int>,less<int> >que4;//最大值优先
    while(!que4.empty())  
    {  
        printf("%3d",que4.top());  
        que4.pop();  
    }  //91 83 72 56 47 36 22 14 10  7  3
      
    //priority_queue<number1>que5; 最小优先级队列  
    while(!que5.empty())  
    {  
        printf("%3d",que5.top());  
        que5.pop();  
    }  //3  7 10 14 22 36 47 56 72 83 91 

    //priority_queue<number2>que6; 最大优先级队列 
    while(!que6.empty())  
    {  
        printf("%3d",que6.top());  
        que6.pop();  
    }  //91 83 72 56 47 36 22 14 10  7  3 
     
    return 0;  
}