STL模板之queue

STL模板之queue

自己学习到的一点点小心得
给自己做的小笔记
queue
queue模板类的定义在头文件中。

与stack模板类很相似，queue模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque类型。

定义queue对象的示例代码如下：

queue<int> q1;

queue<double> q2;

queue的基本操作有：

• 入队，如例：q.push(x); 将x接到队列的末端。

  出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

  访问队首元素，如例：q.front()，即最早被压入队列的元素。

  访问队尾元素，如例：q.back()，即最后被压入队列的元素。

  判断队列空，如例：q.empty()，当队列空时，返回true。

  访问队列中的元素个数，如例：q.size()

#include"iostream"
#include"vector"
#include"queue"
using namespace std;
int main()
{
    queue<int> q;
    int a,chioce,data,sp;
    cin>>a;
    while(a--)
    {
        cin>>chioce;
        switch(chioce)
        {
            case 1:cin>>data;q.push(data);break;
            case 2:if(q.empty())
                    {   
                        cout<<"no"<<endl;
                        continue;
                    }
                    else 
                        cout<<q.front()<<endl;
                        q.pop();//pop并不会返回数据，所以要用到front，再对其pop（）
                    break;
            case 3:
            {
                sp=q.size();
                cout<<sp<<endl;
            }break;
            default: break;
        }
    }
    return 0;
 } 

还有就是在http://blog.csdn.net/f_zyj/article/details/51756880学习到的

priority_queue

在头文件中，还定义了另一个非常有用的模版类priority_queue（优先队列）。优先队列与队列的差别在于优先队列不是按照入队的顺序出队，而是按照队列中元素的优先权出队列（默认为大者优先，也可以通过指定算子来指定自己的优先顺序）。

priority_queue模版类有三个模版参数，第一个是元素类型，第二个是容器类型，第三个是比较算子。其中后两者都可以忽略，默认容器为vector，默认算子为less，即小的往前排，大的往后排（出队列时列尾元素先出队）。
定义priority_queue对象的代码示例：

priority_queue<int> q;
priority_queue<pair<int, int> > qq;                 //  注意在两个尖括号之间一定要留空格，防止误判
priority_queue<int, vector<int>, greater<int> > qqq;//  定义小的先出队列

priority_queue的基本操作与queue的略微不同。

priority_queue的基本操作：

q.empty()     //  如果队列为空，则返回true，否则返回false
q.size()      //  返回队列中元素的个数
q.pop()       //  删除队首元素，但不返回其值
q.top()       //  返回具有最高优先级的元素值，但不删除该元素
q.push(item)  //  在基于优先级的适当位置插入新元素

初学者在使用priority_queue时，最困难的可能就是如何定义比较算子了。如果是基本数据类型，或已定义了比较运算符的类，可以直接使用STL的less算子和greater算子——默认为使用less算子。如果要定义自己的比较算子，方法有多种，这里介绍其中一种：重载比较运算符。优先队列试图这两个元素x和y代入比较运算符（对于less算子，调用x < y，对于greater算子，调用x > y），若结果为真，则x排在y前面，y将先出队列，反之，则y排在x前面，x将先出队列。
如下算子示例：

#include <iostream>
#include <queue>

using namespace std;

class T
{
public:
    int x, y, z;
    T(int a, int b, int c) : x(a), y(b), z(c) {}
};

bool operator < (const T &tOne, const T &tTwo)
{
    return tOne.z < tTwo.z;  //  按照z的顺序来决定tOne和tTwo的顺序
}

int main()
{
    priority_queue<T> q;
    q.push(T(4, 4, 3));
    q.push(T(2, 2, 5));
    q.push(T(1, 5, 4));
    q.push(T(3, 3, 6));

    while (!q.empty())
    {
        T t = q.top();
        q.pop();
        cout << t.x << " " << t.y << " " << t.z << '\n';
    }
    return 0;
}

输出结果为（注意是按照z的顺序从大到小出队列）： 
3 3 6 
2 2 5 
1 5 4 
4 4 3

如果想要按照z的顺序从小到大出队列，只需要改动比较运算符重载为：

bool operator > (const T &tOne, const T &tTwo)
{
    return tOne.z > tTwo.z;  //  按照z的顺序来决定tOne和tTwo的顺序
}

输出结果为：
4 4 3
1 5 4
2 2 5
3 3 6
如果我们把第一个例子中的比较运算符重载为：

bool operator < (const T &tOne, const T &tTwo)
{
    return tOne.z > tTwo.z;  //  按照z的顺序来决定tOne和tTwo的顺序
}

则会得到和第二个例子一样的结果，所以，决定算子的是比较运算符重载函数内部的返回值。