队列的引入lqb--摘抄

大佬：队列是很常见的数据结构，它的存取方式是“先进先出”。生活中的排队，就是队列的原型，例如排队买票，先到先服务。

萌新： 行了行了，别卖关子了，直接说说它怎么实现吧。

大佬：队列有两种实现方式：链队列和循环队列。

• 链队列实际上和单向链表一样，用指针把各个结点连接起来。
• 循环队列使用一组连续的存储单元依次存放队列元素，用指针 head指示队列头元素，rear指向尾元素。当 head和 rear走到底时，下一步回到开始的位置，从而在这组连续空间内循环。设计成循环能解决溢出问题。

 

如果使用环境简单，最简单的队列代码这样写：

const int MAX_N = 1e5;         //队列大小，确保够用 
int que[MAX_N], head, tail;     //队头队尾指针,队列大小为 tail-head+1 
head++;                         //弹出队头，注意head <= tail
que[head];                      //读队头数据
que[++tail] = data;             //数据data入队，尾指针加1，注意不能溢出

 

• 手写循环队列

下面是循环队列的手写模板。

#define MAXQSIZE 100003        //自定义队列大小
struct myqueue{
    int data[MAXQSIZE];      //分配静态空间
    int head;                  //队头，指向队头的元素
    int rear;                //队尾，指向下一个可以放元素的空位置
    bool init(){             //初始化
        head = rear = 0;
        return true;
    }
    int size(){              //返回队列长度
        return (rear - head + MAXQSIZE) % MAXQSIZE;
    }
    bool empty(){            //判断队列是否为空
        if(size()==0) return true;
        else          return false;
    }
    bool push(int e){        //队尾插入新元素。新的rear指向下一个空的位置
         if((rear + 1) % MAXQSIZE == head ) return false; //队列满
         data[rear] = e;
         rear = (rear + 1) % MAXQSIZE;
         return true;
    }
    bool pop(int &e){        //删除队头元素，并返回它
         if(head == rear) return false;   //队列空
         e = data[head];
         head = (head + 1) % MAXQSIZE;
         return true;
    }
    int front(){            //返回队首，但是不删除
        return data[head];
    }
};

 

 

• STL queue

C++的STL queue的部分操作：

queue<Type> q;      //定义队列，Type为数据类型，如int，float，char等
q. push(item);        //把item放进队列
q.front();　　       //返回队首元素，但不会删除
q.pop();        //删除队首元素
q.back();        //返回队尾元素
q.size();　　　　     //返回元素个数
q.empty();　　       //检查队列是否为空 

 

队列的练习

大佬：听我说了这么多早就手痒了吧？试试下面这道题吧。

 

 

#include <bits/stdc++.h>
using namespace std;
int main(){
        queue<int> q;
        int n; cin>>n;
        for(int i=0;i<n;i++)        {
                int num; cin>>num;
                switch(num){
                        case 1:
                                int element;
                                cin>>element;
                q.push(element);
                                break;
                        case 2:
                if(q.empty()==0){
                                        cout<<q.front()<<endl;
                                        q.pop();
                                }
                                else{
                                        cout<<"no"<<endl;
                                        return 0;
                                }
                                break;
                        case 3:
                            cout<<q.size()<<endl;
                                break;
                }
        }
        return 0;
}

 C++：手写队列

#include <bits/stdc++.h>
using namespace std;

#define MAXQSIZE 100003       //自定义队列大小
struct myqueue{
    int data[MAXQSIZE];     //分配静态空间
    int head;                 //队头，指向队头的元素
    int rear;               //队尾，指向下一个可以放元素的空位置
    bool init(){            //初始化
        head = rear = 0;
        return true;
    }
    int size(){             //返回队列长度
        return (rear - head + MAXQSIZE) % MAXQSIZE;
    }
    bool empty(){           //判断队列是否为空
        if(size()==0) return true;
        else         return false;
    }
    bool push(int e){       //队尾插入新元素。新的rear指向下一个空的位置
         if((rear + 1) % MAXQSIZE == head ) return false; //队列满
         data[rear] = e;
         rear = (rear + 1) % MAXQSIZE;
         return true;
    }
    bool pop(int &e){       //删除队头元素，并返回它
         if(head == rear) return false;  //队列空
         e = data[head];
         head = (head + 1) % MAXQSIZE;
         return true;
    }
    int front(){             //返回队首，但是不删除
        return data[head];
    }
}Q;

int main(){
        Q.init();                   //初始化队列
        int n; cin>>n;
        for(int i=0;i<n;i++)        {
                int num; cin>>num;
                switch(num){
                        case 1:
                                int element;
                                cin>>element;
                Q.push(element);
                                break;
                        case 2:
                if(!Q.empty()){
                                        cout<<Q.front()<<endl;
                                        int tmp;
                                        Q.pop(tmp);
                                }
                                else{
                                        cout<<"no"<<endl;
                                        return 0;
                                }
                                break;
                        case 3:
                            cout<<Q.size()<<endl;
                                break;
                }
        }
        return 0;
}

 

 Java：list实现队列

import java.util.ArrayList;
import java.util.Scanner;

public class Main{
        public static void main(String[] arge){
                    Scanner in=new Scanner(System.in);
                int n=in.nextInt();
                ArrayList<Integer> list=new ArrayList<Integer>();
                ArrayList<Integer> lis=new ArrayList<Integer>();
                for(int i=1;i<=n;i++){
                        int x=in.nextInt();
                        if(x==1){
                                int y=in.nextInt();
                                list.add(y);
                        }
                        else if(x==2){
                                if(list.size()>0){
                                        lis.add(list.get(0));
                                        list.remove(0);
                                }
                                else{
                                        for(int k:lis)
                                                System.out.println(k);
                                        System.out.println("no");
                                        return;
                                }
                        }
                        else{
                                lis.add(list.size());
                        }
                }
                for(int k:lis)
                                System.out.println(k);
        }
}

 Python：用queue实现队列

from queue import *

q = Queue()
n = eval(input())
for i in range(n):
    s = list(map(int,input().split()))
    if s[0] == 1:
        q.put(s[1]) 
    elif s[0] == 2:
        if not q.empty():
            a = q.get()
            print(a)
        else:
            print('no')
            break
    elif s[0] == 3:
        print(q.qsize())

Python：用list实现队列

n = eval(input())
q = []
for i in range(n):
    s = list(map(int,input().split()))
    if s[0] == 1:
        q.append(s[1])
    elif s[0] == 2:
        if len(q) > 0:
            q.reverse()
            a = q.pop()
            print(a)
            q.reverse()
        else:
            print('no')
            break
    elif s[0] == 3:
        print(len(q))