9月9日算法学习（队列）

1.模版队列

描述：
请你实现一个队列。
操作：
push x：将 x x 加入队尾，保证 x x 为 int 型整数。
pop：输出队首，并让队首出队
front：输出队首：队首不出队

输入描述：
第一行为一个正整数 n n ，代表操作次数。(1≤n≤100000)(1≤n≤100000)
接下来的 n n ，每行为一个字符串，代表一个操作。保证操作是题目描述中三种中的一种。

输出描述：
如果操作为push，则不输出任何东西。
如果为另外两种，若队列为空，则输出 "error“
否则按对应操作输出。

这个队列可以使用双项链表实现，先使用结构体来构造一个包含存值的int变量，然后在其中加入两个指针，一个指前一个指后，然后从字符串的后面开始遍历，用while提取出数据之后存储，到操作之后直接用等于等于，然后if else来进行处理。

#include 
#include 
using namespace std;
// 双向链表
typedef struct qNode {
    int value;
    qNode* next;
    qNode* pre;
    qNode(int a):value(a),next(nullptr),pre(nullptr){};
} ListNode;
 
int main() {
    ListNode* head = new ListNode(0);
    ListNode* tail = new ListNode(-1);
    head->next = tail;
    tail->pre = head;
 
    string op;
    int t = 0;
    cin>>t;
     
    while (t >= 0) {
        getline(cin, op);  
        int temp = 0;
        if(op.back() != 'p' && op.back() != 't' && op.back() != '\0'){
            int i = 1;   
            while(op.back() != ' '){
                temp = temp +  (op.back() - '0')*i;
                op.pop_back();
                i = i*10;
            } 
            op.pop_back();
        }
        if(op == "push"){ 
            ListNode* NewOne = new ListNode(temp);
            tail->pre->next = NewOne;
            NewOne->pre = tail->pre;
            NewOne->next = tail;
            tail->pre = NewOne;
        }else if (op == "front") { 
            if(head->next == tail){
                cout<<"error"<next->value<next == tail){
                cout<<"error"<next->value<next->next->pre = head;
                head->next = head->next->next;
            }
        }
        t--;
    }
}

2.循环队列

描述：
请你实现一个循环队列，该循环队列可利用的空间大小等于nn个int型变量的大小。

操作：
push x：将xx加入到循环队列尾端。若循环队列已满，输出"full"(不含引号)，否则不输出任何内容。保证xx为int型整数。
front：输出队首元素，队首不出队。若队列为空，输出"empty"(不含引号)。
pop：输出队首元素，且队首出队。若队列为空，输出"empty"(不含引号)。

输入描述：
第一行输入两个整数n,qn,q (1≤n,q≤1051≤n,q≤105)，表示循环队列可利用的空间大小和操作次数。
接下来的qq行，每行一个字符串，表示一个操作。保证操作是题目描述中的一种。
输出描述：
按对应操作要求输出。

这题可以使用双指针来实现，先用while来建立一个包含n+1个节点的队列，但是其中有一个是头结点，所以实际上空间还是n个，然后将最后一个节点的next连到头结点，就形成了循环链表，之后就是用来个指针是否相等来判断是否为空，进行一系列操作了。

#include 
#include 
using namespace std;

struct Node {
    int value = 0;
    Node* next = NULL;
};

int main() {
    int n, q;
    cin >> n >> q;
    Node* head = new Node;
    Node* f = head, *l = head;
    while (n--) {
        Node* temp = new Node;
        l->next = temp;
        l = l->next;
    }
    l->next = head;
    l = head;
    string s;
    int x;
    while (q--) {
        cin >> s;
        if (s == "push") {
            cin >> x;
            if (l->next ==f) 
                cout << "full" << endl;
            else {
                l = l->next;
                l->value = x;
            }
        } else if (s == "front") {
            if (f == l) 
                cout << "empty" << endl;
            else
                cout << f->next->value << endl;
        } else if (s == "pop") {
            if (f == l)
                cout << "empty" << endl;
            else {
                cout << f->next->value << endl;
                f = f->next;
            }
        }
    }
    return 0;
}

谢谢阅读！