寒假Day60：详解-超简单的队列与栈

队列

• 特点：先进先出

• 队列的图：

 

• 队列的基本操作：

#include<stdio.h>
#include<queue>//队列的头文件
using namespace std;//这个也一定要写

//需求：利用queue把1、2、3、4、5都入队，然后依次取出2

queue<int>Q;//设置一个队列叫做Q，存放int类元素

int main()
{

    while(!Q.empty())//清空队列内元素，根据需求
    {//如果开在函数里面或者多组数据时需要清空
        Q.front();
        Q.pop();
    }
    for(int i=1;i<=5;i++)
        Q.push(i);//依次入队
    bool flag=Q.empty();
    printf("判断栈此时是否为空:%d\n\n",flag);//输出1说明空，0说明存在元素
    int w=Q.front();//取出队首元素，此时是1
    printf("此时的栈顶元素：%d\n\n",w);
    Q.pop();//既然此时1已经被取出来了，那么就得从队列中把1删除,这个是删除操作
    w=Q.front();
    Q.pop();
    printf("需要取出的元素：%d\n\n",w);
    while(!Q.empty())
    {
        w=Q.front();
        printf("%d ",w);
        Q.pop();
    }//依次输出队列元素
    return 0;
}

• 用途：用的最广泛的就是bfs，然后还有一些算最短路径、最短步数也会涉及等等

• 例题：POJ1426  参考博客：https://www.cnblogs.com/OFSHK/p/11204426.html

---

优先队列

其实和队列也差不多

队列取出队首元素是front()，优先队列和栈都是top()

例题1：

HDU1873-看病要排队

题目链接：https://vjudge.net/problem/HDU-1873

类似于结构体，一个元素有多个属性，需要根据属性排个队

但是你们可能就想到sort结构体排序了，但是每插入一个元素，sort都需要排一次，浪费大量时间，优先队列是每插入一个元素会自动排序

struct node
{
    int y,id;
    bool operator <(const node &a)const
    {
        if(a.y!=y)
            return a.y>y;
        return a.id<id;
    }
};

 

AC代码：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
typedef long long ll;

struct node
{
    int y,id;
    bool operator <(const node &a)const
    {
        if(a.y!=y)
            return a.y>y;
        return a.id<id;
    }
};

char a[5];

int main()
{
    int n,aa,bb;
    priority_queue<node>Q[5];
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=3; i++)
        {
            while(!Q[i].empty())
                Q[i].pop();
        }
        int w=1;
        for(int i=1; i<=n; i++)
        {
            scanf("%s",a);
            if(a[0]=='I')
            {
                cin>>aa>>bb;
                node p;
                p.id=w;
                p.y=bb;
                Q[aa].push(p);
                w++;
            }
            else
            {
                cin>>aa;
                if(Q[aa].empty())
                    cout<<"EMPTY"<<endl;
                else
                {
                    node p;
                    // p=Q[aa].front();
                    p=Q[aa].top();
                    Q[aa].pop();
                    cout<<p.id<<endl;
                }
            }
        }
    }
    return 0;
}

 

例题2：

如果还不了解哈夫曼树的话，这个可以先放一下

POJ1521

题目链接：http://poj.org/problem?id=1521

参考博客：https://www.cnblogs.com/OFSHK/p/12544649.html

记住这个就可以了：

priority_queue<int,vector<int>,greater<int> >Q;

这个表示从小到大入队。

 

还有一个是：

priority_queue<int, vector<int>, less<int> > Q;

表示从大到小入队。

 

区别一下，并且注意一下：注意最后两个>之间有一个空格，表示重载（这个以后了解就好啦）

 

你们可能会想用sort，

但是根据哈夫曼树来说，每次取出最小的两个元素，还需要将这两个元素相加的值再按照从小到大放入队列中，

所以还是先去了解一个哈夫曼树这个数据结构吧。

 

---

 

栈

• 特点：先进后出

• 栈的图：

 

 

•  栈的基本操作：

#include<stdio.h>
#include<stack>//栈的头文件
using namespace std;//这个也一定要写

//需求：利用stack把1、2、3、4、5都入栈，但是需要利用出栈的形式取出3

stack<int>s;//设置一个栈叫做s，存放int类元素

int main()
{
    while(!s.empty())//清空栈内元素，根据需求
    {//如果开在函数里面或者多组数据时需要清空
        s.top();
        s.pop();
    }
    s.push(1);//分辨让规定元素入栈
    s.push(2);
    s.push(3);
    int w=s.top();//取出栈顶元素，此时是3
    printf("此时的栈顶元素：%d\n\n",w);
    s.pop();//既然此时3已经被取出来了，那么就得从栈中把3删除,这个是删除操作
    s.push(4);//继续存入后继元素
    s.push(5);
    while(!s.empty())
    {
        w=s.top();
        printf("%d ",w);
        s.pop();
    }//依次输出栈内元素
    printf("\n");
    bool flag=s.empty();
    printf("判断栈此时是否为空:%d\n",flag);//输出1说明空
    return 0;
}

 

我感觉栈的用途还是比较少的，可能是我没碰到多少吧。