C++ STL之栈&队列&优先队列

stack

栈是一种容器适配器，特别为后入先出而设计的一种（LIFO ），那种数据被插入，然后再容器末端取出

栈实现了容器适配器，这是用了一个封装了的类作为他的特定容器，提供了一组成员函数去访问他的元素，元素从特定的容器，也就是堆栈的头取出元素。

这个基础的容器可能是任何标准的容器类，和一些其他特殊设计的模板类。
实现C++ STL，栈有两个参数。

template < class T, class Container = deque<T> > class stack;

参数示意：

T: 元素类型
Container: 被用于存储和访问元素的的类型

主要的方法有如下：

                      empty() 堆栈为空则返回真
　　                   pop() 移除栈顶元素（不会返回栈顶元素的值） 
　　                   push() 在栈顶增加元素
　　                   size() 返回栈中元素数目
　　                   top() 返回栈顶元素

#include <iostream>
#include <stack>
using namespace std;
int main()
{
    stack <int> S;  //定义栈 
    S.push(5);//入栈 
    S.push(6);
    S.push(7);
    S.pop(); //出栈 
    cout<<S.top()<<endl;//输出栈顶元素 
    cout<<S.size()<<endl;//输出栈的大小 
    cout<<S.empty()<<endl;//判断栈是不是空 
    return 0;
}

---

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 <queue>
using namespace std;
int main()
{
    int e, n, m;
    queue<int> q1;
    for(int i = 0; i < 10; i++)
       q1.push(i);//入队 
    if(!q1.empty())
    cout << "队列不空\n";
    n = q1.size();
    cout << n << endl;
    m = q1.back();
    cout << m << endl;
    for(int j = 0; j < n; j++)
    {
       e = q1.front();
       cout << e << " ";
       q1.pop();
    }
    cout << endl;
    if(q1.empty())
    cout << "空队列\n";
    return 0;
}

priority_queue

priority_queue 对于基本类型的使用方法相对简单。他的模板声明带有三个参数，priority_queue<Type, Container, Functional>
Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。
Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list.
STL里面容器默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参数 缺省的话，优先队列就是大顶堆，队头元素最大。
看例子

#include <iostream>
#include <queue>
using namespace std;
int main()
{
    priority_queue<int,vector<int>,less<int> >q1;//使用priority_queue<int> q1;一样 
    for(int i = 0; i < 10; i++) 
        q1.push(i);
    while(!q1.empty())
    {
        cout << q1.top() << endl;
        q1.pop();
    }
    return 0;
}

如果要用到小顶堆，则一般要把模板的三个参数都带进去。
STL里面定义了一个仿函数 greater<>，对于基本类型可以用这个仿函数声明小顶堆
例子:

#include <iostream>
#include <queue>
using namespace std;
int main()
{
    priority_queue<int,vector<int>,greater<int> >q;
    for(int i = 0; i < 10; i++) 
        q.push(i);
    while(!q.empty())
    {
        cout << q.top() << endl;
        q.pop();
    }
    return 0;
}

对于自定义类型，则必须自己重载 operator< 或者自己写仿函数先看看例子:

#include <iostream>
#include <queue>
using namespace std;
struct Node
{
    int x, y;
}node;
bool operator < ( Node a, Node b)
{
    if(a.x == b.x)
        return a.y > b.y;
    return a.x > b.x;
}
 int main(){
    priority_queue<Node> q;
    for(int i = 0;i < 10; i++)
    {
        node.x = i;
        node.y = 10 - i / 2;
        q.push(node);
    }   
    while(!q.empty())
    {
        cout << q.top().x << ' ' << q.top().y << endl;
        q.pop();
    }
    return 0;
}

自定义类型重载 operator< 后，声明对象时就可以只带一个模板参数。
此时不能像基本类型这样声明priority_queue<Node, vector<Node>, greater<Node> >;
原因是 greater<Node> 没有定义，如果想用这种方法定义
则可以按如下方式

例子:

#include <iostream>
#include <queue>
using namespace std;
struct Node
{
    int x, y;
}node;
struct cmp
{
    bool operator()(Node a,Node b)
    {
        if(a.x == b.x)
            return a.y>b.y;
        return a.x>b.x;
    }
};

int main()
{
   priority_queue<Node,vector<Node>,cmp> q;
   for(int i = 0; i < 10; i++)
   {
    node.x = i;
    node.y = 10 - i / 2;
    q.push(node);
   }    
   while(!q.empty())
   {
       cout << q.top().x << ' ' << q.top().y << endl;
       q.pop();
   }
   return 0;
}