猫狗队列

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdbool.h>

typedef struct {
    int id;
    int txid;
} pet;

typedef struct {
    pet *arr;
    int front;
    int rear;
    int arr_len;
} queue;

queue *new_queue(int cap);

void add(queue *q, pet p);

pet poll(queue *q);

pet front(queue *q);

bool is_empty(queue *q);

void free_queue(queue *q);

int main(void) {
    int n, txid = 0;
    char buf[15];
    pet p;
    scanf("%d", &n);
    queue *cq = new_queue(n);
    queue *dq = new_queue(n);
    for (int i = 0; i < n; i++) {
        scanf("%s", buf);
        if (strcmp("add", buf) == 0) {
            scanf("%s", buf);
            scanf("%d", &p.id);
            p.txid = txid++;
            if (strcmp("cat", buf) == 0)
                add(cq, p);
            else
                add(dq, p);
        } else if (strcmp("pollAll", buf) == 0) {
            while (!is_empty(cq) && !is_empty(dq)) {
                if (front(cq).txid < front(dq).txid)
                    printf("%s %d\n", "cat", poll(cq).id);
                else
                    printf("%s %d\n", "dog", poll(dq).id);
            }
            while (!is_empty(dq))
                printf("%s %d\n", "dog", poll(dq).id);
            while (!is_empty(cq))
                printf("%s %d\n", "cat", poll(cq).id);
        } else if (strcmp("pollDog", buf) == 0) {
            while (!is_empty(dq))
                printf("%s %d\n", "dog", poll(dq).id);
        } else if (strcmp("pollCat", buf) == 0) {
            while (!is_empty(cq))
                printf("%s %d\n", "cat", poll(cq).id);
        } else if (strcmp("isEmpty", buf) == 0) {
            printf("%s\n", (is_empty(cq) && is_empty(dq))? "yes" : "no");
        } else if (strcmp("isDogEmpty", buf) == 0) {
            printf("%s\n", is_empty(dq) ? "yes" : "no");
        } else if (strcmp("isCatEmpty", buf) == 0) {
            printf("%s\n", is_empty(cq) ? "yes" : "no");
        }
    }
    free_queue(cq);
    free_queue(dq);
    return 0;
}

queue *new_queue(int cap) {
    queue *q = (queue *) malloc(sizeof(queue));
    q->arr = (pet *) malloc(sizeof(pet) * (cap + 1));
    q->front = 1;
    q->rear = 0;
    q->arr_len = cap + 1;
    return q;
}

void add(queue *q, pet p) {
    q->rear = (q->rear + 1) % q->arr_len;
    q->arr[q->rear] = p;
}

pet poll(queue *q) {
    pet p = q->arr[q->front];
    q->front = (q->front + 1) % q->arr_len;
    return p;
}

pet front(queue *q) {
    return q->arr[q->front];
}

bool is_empty(queue *q) {
    return (q->rear + 1) % q->arr_len == q->front;
}

void free_queue(queue *q) {
    free(q->arr);
    free(q);
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

    // 题目中给定的类
    public static class Pet{
        private String type;
        private int x;

        public Pet (String type,int x){
            this.type = type;
            this.x = x;
        }

        public String getPetType(){
            return this.type;
        }

        public int getX(){
            return this.x;
        }
    }

    public static class Dog extends Pet{
        public Dog(int x) {
            super("dog", x);
        }
    }

    public static class Cat extends Pet{
        public Cat(int x){
            super("cat", x);
        }
    }

    // 可以为不同的实例盖上时间戳的新的类
    public static class PetEnterQueue{
        private Pet pet;
        private long count;

        public PetEnterQueue(Pet pet, long count) {
            this.pet = pet;
            this.count = count;
        }

        public Pet getPet() {
            return pet;
        }

        public long getCount() {
            return count;
        }

        public String getEnterPetType(){
            return this.pet.getPetType();
        }
    }

    // 猫狗队列
    public static class DogCatQueue{
        private Queue<PetEnterQueue> dogQ;
        private Queue<PetEnterQueue> catQ;
        private long count;

        public DogCatQueue() {
            this.dogQ = new LinkedList<>();
            this.catQ = new LinkedList<>();
            this.count = 0;
        }

        public void add(Pet pet){
            if (pet.getPetType().equals("dog")){
                this.dogQ.add(new PetEnterQueue(pet,this.count++));
            } else if (pet.getPetType().equals("cat")){
                this.catQ.add(new PetEnterQueue(pet,this.count++));
            } else {
                throw new RuntimeException("error, not dog&nbs***bsp;cat");
            }
        }

        // 注意弹出的不能是自己定义的PetEnterQueue
        public Pet pollAll(){
            if (!this.dogQ.isEmpty() && !this.catQ.isEmpty()){
                if (this.dogQ.peek().count < this.catQ.peek().count){
                    return this.dogQ.poll().getPet();
                } else {
                    return this.catQ.poll().getPet();
                }
            } else if(!this.dogQ.isEmpty()){
                return this.dogQ.poll().getPet();
            } else if(!this.catQ.isEmpty()){
                return this.catQ.poll().getPet();
            } else {
                throw new RuntimeException("error,queue is empty");
            }
        }

        public Dog pollDog(){
            if (!dogQ.isEmpty()){
                return (Dog) this.dogQ.poll().getPet();
            } else {
                throw new RuntimeException("Dog queue is empty.");
            }
        }

        public Cat pollCat(){
            if (!catQ.isEmpty()){
                return (Cat) this.catQ.poll().getPet();
            } else {
                throw new RuntimeException("Cat queue is empty.");
            }
        }

        public boolean isEmpty(){
            return this.catQ.isEmpty() && this.dogQ.isEmpty();
        }

        public boolean isDogQueueEmpty(){
            return this.dogQ.isEmpty();
        }

        public boolean isCatQueueEmpty(){
            return this.catQ.isEmpty();
        }
    }

    public static void main(String[] args) throws IOException {
        DogCatQueue dogCatQueue = new DogCatQueue();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(in.readLine());
        StringBuilder res = new StringBuilder();
        Pet pet = null;

        while (n-->0){
            String[] strArr = in.readLine().split(" ");
            String ops = strArr[0];
            switch (ops){
                case "add":
                    if ("dog".equals(strArr[1])){
                        dogCatQueue.add(new Dog(Integer.parseInt(strArr[2])));
                    } else if ("cat".equals(strArr[1])){
                        dogCatQueue.add(new Cat(Integer.parseInt(strArr[2])));
                    } else {
                        throw new RuntimeException("Invalid add.");
                    }
                    break;
                case "pollAll":
                    while (!dogCatQueue.isEmpty()){
                        pet = dogCatQueue.pollAll();
                        // 用链式append没有警告！！
                        // 类型和分数中间记得加上空格
                        res.append(pet.getPetType()).append(" ").append(pet.getX()).append('\n');
                    }
                    break;
                case "pollDog":
                    while (!dogCatQueue.isDogQueueEmpty()){
                        pet = dogCatQueue.pollDog();
                        res.append("dog").append(" ").append(pet.getX()).append('\n');
                    }
                    break;
                case "pollCat":
                    while (!dogCatQueue.isCatQueueEmpty()){
                        pet = dogCatQueue.pollCat();
                        res.append("cat").append(" ").append(pet.getX()).append('\n');
                    }
                    break;
                case "isEmpty":
                    if (!dogCatQueue.isEmpty()){
                        res.append("no").append('\n');
                    } else {
                        res.append("yes").append('\n');
                    }
                    break;
                case "isDogEmpty":
                    if(!dogCatQueue.isDogQueueEmpty()){
                        res.append("no").append('\n');
                    } else {
                        res.append("yes").append('\n');
                    }
                    break;
                case "isCatEmpty":
                    if(!dogCatQueue.isCatQueueEmpty()){
                        res.append("no").append('\n');
                    } else {
                        res.append("yes").append('\n');
                    }
                    break;
            }
        }
        // 最后的输出只能由一个回车，所以是System.out.println(res.substring(0,res.length()-1));或者下面这个
        System.out.print(res);
    }
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,id=0;
    cin>>n;
    string s,t;
    queue<pair<int, unsigned long>> c,d;
    while(n--)
    {
        cin>>s;
        if(s=="add")
        {
            cin>>t>>m;
            if(t=="cat")
                c.push({m, id});
            else if(t=="dog")
                d.push({m, id});
            id++;
        }
        else if(s=="pollCat")
        {
            while(!c.empty()){
                cout<<"cat "<<c.front().first<<endl;
                c.pop();
            }
        }
        else if(s=="pollDog")
        {
            while(!d.empty()){
                cout<<"dog "<<d.front().first<<endl;
                d.pop();
            }
        }
        else if(s=="pollAll")
        {
            while(!c.empty()&&!d.empty())
            {
                if(c.front().second<=d.front().second){
                    cout<<"cat "<<c.front().first<<endl;
                    c.pop();
                }
                else{
                    cout<<"dog "<<d.front().first<<endl;
                    d.pop();
                }
            }
            while(!c.empty()){
                cout<<"cat "<<c.front().first<<endl;
                c.pop();
            }
            while(!d.empty()){
                cout<<"dog "<<d.front().first<<endl;
                d.pop();
            }
        }
        else if(s=="isDogEmpty")
        {
            if(d.empty())
                cout<<"yes"<<endl;
            else
                cout<<"no"<<endl;
        }
        else if(s=="isCatEmpty")
        {
            if(c.empty())
                cout<<"yes"<<endl;
            else
                cout<<"no"<<endl;
        }
        else if(s=="isEmpty")
        {
            if(c.empty()&&d.empty())
                cout<<"yes"<<endl;
            else
                cout<<"no"<<endl;
        }
    }
    return 0;
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Pet{
    private String type;

    private String name;

    public Pet(String type, String name){
        this.type = type;
        this.name = name;
    }

    public String getPetType(){
        return type;
    }

    public String getName(){
        return name;
    }
}

class Dog extends Pet{
    public Dog(String name){
        super("Dog", name);
    }
}

class Cat extends Pet{
    public Cat(String name){
        super("Cat", name);
    }
}

class PetEnterQueue{
    private Pet pet;
    private long count;

    public PetEnterQueue(Pet pet, long count) {
        this.pet = pet;
        this.count = count;
    }

    public Pet getPet() {
        return pet;
    }

    public long getCount() {
        return count;
    }
}

public class Main {
    private Queue<PetEnterQueue> catQueue = new LinkedList<>();
    private Queue<PetEnterQueue> dogQueue = new LinkedList<>();
    private long count = 0;

    void add(Pet pet){
        ++count;
        if (pet.getPetType().equals("Dog")){
            dogQueue.add(new PetEnterQueue(pet, count));
        }else{
            catQueue.add(new PetEnterQueue(pet, count));
        }
    }

    ArrayList<Cat> pollCat(){
        ArrayList<Cat> cats = new ArrayList<>();
        while (!isCatEmpty()){
            cats.add((Cat)catQueue.poll().getPet());
        }
        return cats;
    }

    ArrayList<Dog> pollDog(){
        ArrayList<Dog> dogs = new ArrayList<>();
        while (!isDogEmpty()){
            dogs.add((Dog)dogQueue.poll().getPet());
        }
        return dogs;
    }

    ArrayList<Pet> pollAll(){
        ArrayList<Pet> arrayList = new ArrayList<>();

        while (!isCatEmpty() && !isDogEmpty()) {
            if (catQueue.peek().getCount() < dogQueue.peek().getCount()) {
                arrayList.add(catQueue.poll().getPet());
            } else {
                arrayList.add(dogQueue.poll().getPet());
            }
        }

        while (!isCatEmpty()){
            arrayList.add(catQueue.poll().getPet());
        }

        while (!isDogEmpty()){
            arrayList.add(dogQueue.poll().getPet());
        }

        return arrayList;
    }

    boolean isDogEmpty(){
        return dogQueue.isEmpty();
    }

    boolean isCatEmpty(){
        return catQueue.isEmpty();
    }

    boolean isEmpty(){
        return isCatEmpty() && isDogEmpty();
    }

    public static void main(String[] args) throws IOException {
        Main catAndDogQueue = new Main();
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int number = Integer.parseInt(bf.readLine());
        while (number > 0){
            --number;
            String input = bf.readLine();
            if (input.startsWith("add")){
                String pet = input.substring(input.indexOf(' ') + 1);

                if (pet.startsWith("cat")){
                    Cat cat = new Cat(pet);
                    catAndDogQueue.add(cat);
                }else{
                    Dog dog = new Dog(pet);
                    catAndDogQueue.add(dog);
                }
            } else if (input.startsWith("pollAll")){
                ArrayList<Pet> pets = catAndDogQueue.pollAll();
                for (Pet pet: pets){
                    System.out.println(pet.getName());
                }
            } else if (input.startsWith("isEmpty")){
                System.out.println(catAndDogQueue.isEmpty() ? "yes" : "no");
            } else if (input.startsWith("isDogEmpty")){
                System.out.println(catAndDogQueue.isDogEmpty() ? "yes" : "no");
            } else if (input.startsWith("isCatEmpty")){
                System.out.println(catAndDogQueue.isCatEmpty() ? "yes" : "no");
            } else if (input.startsWith("pollCat")){
                ArrayList<Cat> pets = catAndDogQueue.pollCat();
                for (Pet pet: pets){
                    System.out.println(pet.getName());
                }
            } else if (input.startsWith("pollDog")){
                ArrayList<Dog> pets = catAndDogQueue.pollDog();
                for (Pet pet: pets){
                    System.out.println(pet.getName());
                }
            }
        }
    }
}

使用Java语言时，如果每次结果都立即输出，那么会因多次IO操作而超时，可以先用StringBuilder拼接输出，最后再一次性输出结果，缺点是占用内存较多。

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

int main(){
    int n, x;
    string s, t;
    queue<int> Q_cat, Q_dog, Q_all;
    cin>>n;
    while(n--){
        cin>>s;
        if(s=="add"){
            cin>>t>>x;
            if(t=="cat")
                Q_cat.push(x);
            else
                Q_dog.push(x);
            Q_all.push(x);
        }else if(s=="isCatEmpty"){
            printf("%s\n", (Q_cat.empty()?"yes":"no"));
        }else if(s=="isDogEmpty"){
            printf("%s\n", (Q_dog.empty()?"yes":"no"));
        }else if(s=="isEmpty"){
            printf("%s\n", ((Q_cat.empty()&&Q_dog.empty())?"yes":"no"));
        }else if(s=="pollCat"){
            while(!Q_cat.empty()){
                x = Q_cat.front();
                Q_cat.pop();
                if(x==Q_all.front())
                    Q_all.pop();
                printf("cat %d\n", x);
            }
        }else if(s=="pollDog"){
            while(!Q_dog.empty()){
                x = Q_dog.front();
                Q_dog.pop();
                if(x==Q_all.front())
                    Q_all.pop();
                printf("dog %d\n", x);
            }
        }else if(s=="pollAll"){
            while(!Q_all.empty()){
                x = Q_all.front();
                if(!Q_cat.empty() && x==Q_cat.front()){
                    Q_cat.pop();
                    printf("cat %d\n", x);
                }else if(!Q_dog.empty() && x==Q_dog.front()){
                    Q_dog.pop();
                    printf("dog %d\n", x);
                }
                Q_all.pop();
            }
        }
    }
    return 0;
}

#include <iostream>
#include <queue>
#include <string>
using namespace std;

int main() {
    int n;
    cin >> n;
    n++;
    queue<string>allQueue;
    queue<string>catQueue;
    queue<string>dogQueue;
    while (n--) {
        string cmd;
        getline(cin, cmd);
        if (cmd.size() == 0)
            continue;
        if (cmd == "pollAll") {
            while (!allQueue.empty()) {
                cout << allQueue.front() << endl;
                allQueue.pop();
            }
            while (!catQueue.empty()) {
                catQueue.pop();
            }
            while (!dogQueue.empty()) {
                dogQueue.pop();
            }
        } else if (cmd == "pollDog") {
            while (!dogQueue.empty()) {
                cout << dogQueue.front() << endl;
                dogQueue.pop();
            }
            while (!allQueue.empty()) {
                allQueue.pop();
            }
            allQueue = catQueue;
        } else if (cmd == "pollCat") {
            while (!catQueue.empty()) {
                cout << catQueue.front() << endl;
                catQueue.pop();
            }
            while (!allQueue.empty()) {
                allQueue.pop();
            }
            allQueue = dogQueue;
        } else if (cmd == "isEmpty") {
            if (allQueue.empty())
                cout << "yes" << endl;
            else
                cout << "no" << endl;
        } else if (cmd == "isDogEmpty") {
            if (dogQueue.empty())
                cout << "yes" << endl;
            else
                cout << "no" << endl;
        } else if (cmd == "isCatEmpty") {
            if (catQueue.empty())
                cout << "yes" << endl;
            else
                cout << "no" << endl;
        } else {
            string tmpStr;
            tmpStr.append(cmd, 4, cmd.size() - 4);
            string animalStr = tmpStr.substr(0,3);
            if (animalStr == "cat") {
                catQueue.push(tmpStr);
                allQueue.push(tmpStr);
            } else if (animalStr == "dog"){
                dogQueue.push(tmpStr);
                allQueue.push(tmpStr);
            }
        }
    }
}
// 64 位输出请用 printf("%lld")

用例是否有问题？这是用例输入和我觉得应该的输出，我的输出和这个是一样的但是预期输出却和我的不一样

using namespace std;
#include<queue>
#include<string>
#include<utility>
struct animal//定义动物结构体
{
    string type;//动物类型，猫或狗
    int num;//猫和狗的编号
    int count_;
};
template<class T>
class Linkqueue
{
public:
    //构造函数，析构函数，入队，全部出队，猫出队，狗出队，判空
    Linkqueue();//构造函数
    ~Linkqueue();//析构函数
    void add(animal a);//入队
    void pollAll();//全部出队
    animal pollCat();//猫出队
    animal pollDog();//狗出队
    string isEmpty();//猫狗队列判空
    string isCatEmpty();//猫队列判空
    string isDogEmpty();//狗队列判空
private:
    int order;//记录猫和狗进入的顺序
    queue<animal>Catqueue;//猫队列
    queue<animal>Dogqueue;//狗队列
    queue<animal>Allqueue;//猫狗队列
};
template<class T>
Linkqueue<T>::Linkqueue()//构造函数
{
    order=0;
}
template<class T>
Linkqueue<T>::~Linkqueue()
{
    //析构函数
}
template<class T>
void Linkqueue<T>::add(animal a)//入队
{
    if(a.type=="cat")
        {Catqueue.push(a);//让动物a进入cat队列
        a.count_=order;
        order++;}
    else if(a.type=="dog")
        {Dogqueue.push(a);//让动物a进入dog队列
        a.count_=order;
        order++;}
    Allqueue.push(a);//动物a进入all队列
}
template<class T>
void Linkqueue<T>::pollAll()//全部出队,按照进队列的先后顺序依次弹出
{
    while(!Allqueue.empty())//如果猫队列和狗队列都不为空
    {
        animal res;
        res=Allqueue.front();//将猫狗队列的队首元素赋值给res
        cout<<res.type<<" "<<res.num<<endl;
        if(res.type=="cat")
        {
            Catqueue.pop();//将猫队列的队首元素弹出
        }
        else if(res.type=="dog")
        {
            Dogqueue.pop();
        }
        Allqueue.pop();
    }
}
template<class T>
animal Linkqueue<T>::pollCat()//猫队列队头元素出队
{
    animal res;
    if(!Catqueue.empty())//若猫队列不为空
    {
        res=Catqueue.front();//将猫队列的队首元素赋值给res
        cout<<res.type<<" "<<res.num<<endl;
        Catqueue.pop();//弹出猫队列的队首元素
        Allqueue.pop();
    }
    else
    {
        res.type="null";
        res.num=-1;
    }
    return res;
}
template<class T>
animal Linkqueue<T>::pollDog()//狗队列队头元素出队
{
    animal res;
    if(!Dogqueue.empty())//若狗队列不为空
    {
        res=Dogqueue.front();
        cout<<res.type<<" "<<res.num<<endl;
        Dogqueue.pop();
        Allqueue.pop();
    }
    else
    {
        res.type="null";
        res.num=-1;
    }
    return res;
}
template<class T>
string Linkqueue<T>::isEmpty()//猫狗队列判空
{
    if(!Allqueue.empty())//不为空
        return "no";
    else
        return "yes";
}
template<class T>
string Linkqueue<T>::isCatEmpty()//猫队列判空
{
    if(!Catqueue.empty())//猫队列不为空
        return "no";
    else
        return "yes";
}
template<class T>
string Linkqueue<T>::isDogEmpty()//狗队列判空
{
    if(!Dogqueue.empty())//狗队列不为空
        return "no";
    else
        return "yes";
}
int main()
{
    Linkqueue<animal>animalQueue{};
    int n;//用户的操作总数
    cin>>n;
    for(int i=0;i<n;i++)
    {
        string str;
        cin>>str;
        if(str=="add")
            {
                animal a;
                string c;
                int x;
                cin>>c>>x;
                a.num=x;
                a.type=c;
                animalQueue.add(a);
            }
        else if(str=="pollAll")
            {
                animalQueue.pollAll();
            }
        else if(str=="pollCat")
        {
            animalQueue.pollCat();
        }
        else if(str=="pollDog")
        {
            animalQueue.pollDog();
        }
        else if(str=="isEmpty")
        {
            cout<<animalQueue.isEmpty()<<endl;
        }
        else if(str=="isCatEmpty")
        {
            cout<<animalQueue.isCatEmpty()<<endl;
        }
        else if(str=="isDogEmpty")
        {
            cout<<animalQueue.isDogEmpty()<<endl;
        }
    }
    return 0;
}

# 存放动物的类
class Pet:
    def __init__(self, type, id):
        # 动物类型
        self.type = type
        # 动物编号
        self.id = id

    def getType(self):
        return self.type

    def getID(self):
        return self.id


# 带有时间戳的动物
class PetWithTime:
    def __init__(self, pet: Pet, time):
        self.pet = pet
        self.time = time

    def getPet(self):
        return self.pet

    def getTime(self):
        return self.time

    def getPetType(self):
        return self.pet.type


# 猫狗队列
class CatDogQueue:
    def __init__(self):
        # 分别存放猫,狗的队列
        self.dog_queue = []
        self.cat_queue = []
        self.dog_num = 0
        self.cat_num = 0
        # 时间戳
        self.time = 0

    # add操作
    def add(self, pet):
        self.time += 1
        # 加入时间戳
        pet_with_time = PetWithTime(pet, self.time)
        if pet_with_time.getPetType() == 'dog':
            self.dog_queue.append(pet_with_time)
            self.dog_num += 1
        else:
            self.cat_queue.append(pet_with_time)
            self.cat_num += 1

    # 出队操作
    def pollAll(self):
        while self.dog_num > 0 and self.cat_num > 0:
            # 选择时间戳小的弹出队列
            if self.dog_queue[0].getTime() < self.cat_queue[0].getTime():
                pet = self.dog_queue.pop(0).getPet()
                print('{} {}'.format(pet.getType(), pet.getID()))
                self.dog_num -= 1
            else:
                pet = self.cat_queue.pop(0).getPet()
                print('{} {}'.format(pet.getType(), pet.getID()))
                self.cat_num -= 1
        self.pollDog()
        self.pollCat()

    def pollCat(self):
        while self.cat_num > 0:
            pet = self.cat_queue.pop(0).getPet()
            print('{} {}'.format(pet.getType(), pet.getID()))
            self.cat_num -= 1

    def pollDog(self):
        while self.dog_num > 0:
            pet = self.dog_queue.pop(0).getPet()
            print('{} {}'.format(pet.getType(), pet.getID()))
            self.dog_num -= 1

    def isEmpty(self):
        if self.dog_num == 0 and self.cat_num == 0:
            print('yes')
        else:
            print('no')

    def isCatEmpty(self):
        if self.cat_num == 0:
            print('yes')
        else:
            print('no')

    def isDogEmpty(self):
        if self.dog_num == 0:
            print('yes')
        else:
            print('no')


# 操作次数
n = int(input())
# 猫狗队列
cat_dog_queue = CatDogQueue()
for i in range(n):
    operator = input().split()
    if operator[0] == 'add':
        pet = Pet(operator[1], operator[2])
        cat_dog_queue.add(pet)
    elif operator[0] == 'pollAll':
        cat_dog_queue.pollAll()
    elif operator[0] == 'pollDog':
        cat_dog_queue.pollDog()
    elif operator[0] == 'pollCat':
        cat_dog_queue.pollCat()
    elif operator[0] == 'isEmpty':
        cat_dog_queue.isEmpty()
    elif operator[0] == 'isDogEmpty':
        cat_dog_queue.isDogEmpty()
    elif operator[0] == 'isCatEmpty':
        cat_dog_queue.isCatEmpty()

八点想吃🍞

let line=readline()
let dogQueue=[],catQueue=[]
let time=0
while(line=readline()){
    let [action,name,index]=line.split(" ")
    if(action=='add'){
        let num=parseInt(index)
        if(name=='cat'){
            catQueue.push({
                num,
                time
            })
        }else{
             dogQueue.push({
                num,
                time
            })
        }
        time++
    }else if(action=='pollAll'){
        while(dogQueue.length&&catQueue.length){
            if(dogQueue[0].time<catQueue[0].time){
                console.log("dog "+dogQueue.shift().num)
            }else{
                console.log("cat "+catQueue.shift().num)
            }
        }
        if(dogQueue.length&&catQueue.length==0){
            while(dogQueue.length)
            console.log("dog "+dogQueue.shift().num)
        }
        if(dogQueue.length==0&&catQueue.length){
            while(catQueue.length)
            console.log("cat "+catQueue.shift().num)
        }
    }else if(action=='pollDog'){
         while(dogQueue.length){
                console.log("dog "+dogQueue.shift().num)         
        }
    }else if(action=='pollCat'){
         while(catQueue.length){
                console.log("cat "+catQueue.shift().num)         
        } 
    }else if(action=='isEmpty'){
        console.log(dogQueue.length==0&&catQueue.length==0?'yes':'no') 
    }else if(action=='isDogEmpty'){
        console.log(dogQueue.length==0?'yes':'no') 
    }else{
        console.log(catQueue.length==0?'yes':'no') 
    }
}

#include <iostream>
#include <queue>
#include <string>
using namespace std;

static int counts;

enum {
    cat,
    dog
};

struct pet {
    int kind;
    int id;
    int counts;
};

struct MyQueue {
    queue<pet> cat_queue;
    queue<pet> dog_queue;

    void add(int kind, int id, int counts) {
        if (kind == cat)
            cat_queue.push({ kind, id, counts });
        else
            dog_queue.push({ kind, id, counts });
    }

    void pollAll() {
        while (!cat_queue.empty() && !dog_queue.empty()) {
            if (cat_queue.front().counts > dog_queue.front().counts) {
                cout << "dog " << dog_queue.front().id << endl;
                dog_queue.pop();
            }
            else {
                cout << "cat " << cat_queue.front().id << endl;
                cat_queue.pop();
            }

        }
        while (!cat_queue.empty()) {
            cout << "cat " << cat_queue.front().id << endl;
            cat_queue.pop();
        }
        while (!dog_queue.empty()) {
            cout << "dog " << dog_queue.front().id << endl;
            dog_queue.pop();
        }
    }

    void pollDog() {
        while (!dog_queue.empty()) {
            cout << "dog " << dog_queue.front().id << endl;
            dog_queue.pop();
        }
    }

    void pollCat() {
        while (!cat_queue.empty()) {
            cout << "cat " << cat_queue.front().id << endl;
            cat_queue.pop();
        }
    }

    void isEmpty() {
        if (dog_queue.empty() && cat_queue.empty())
            cout << "yes" << endl;
        else
            cout << "no" << endl;
    }

    void isDogEmpty() {
        if (dog_queue.empty())
            cout << "yes" << endl;
        else
            cout << "no" << endl;
    }

    void isCatEmpty() {
        if (cat_queue.empty())
            cout << "yes" << endl;
        else
            cout << "no" << endl;
    }

};

int main(void) {
    int n;
    MyQueue mq;
    cin >> n;
    string s;
    string kind;
    int id;
    for (int i = 0; i < n; i++) {
        cin >> s;
        if (s == "add") {
            cin >> kind;
            cin >> id;
            if (kind == "cat") {
                mq.add(cat, id, counts++);
            }
            else {
                mq.add(dog, id, counts++);
            }
        }
        else if (s == "pollAll") {
            mq.pollAll();
        }
        else if (s == "pollCat") {
            mq.pollCat();
        }
        else if (s == "pollDog") {
            mq.pollDog();
        }
        else if (s == "isEmpty") {
            mq.isEmpty();
        }
        else if (s == "isDogEmpty") {
            mq.isDogEmpty();
        }
        else {
            mq.isCatEmpty();
        }
    }
    return 0;
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            Deque<String> cat=new LinkedList<>();
            Deque<String> dog=new LinkedList<>();
            Deque<String> all=new LinkedList<>();
            StringBuilder sb=new StringBuilder();
            int n=sc.nextInt();
            for(int i=0;i<n;i++){
                String op=sc.next();
                switch (op){
                    case "add":
                        String who=sc.next();
                        int num=sc.nextInt();
                        if(who.equals("cat")){
                            cat.addLast("cat "+num);
                        }else{
                            dog.addLast("dog "+num);
                        }
                        all.addLast(who+" "+num);
                        break;
                    case "pollAll":
                        while(!all.isEmpty()){
                            String str=all.pop();
                            if(!cat.isEmpty()&&str.equals(cat.peekFirst())){
                                 sb.append(str).append("\n");
                                 cat.pop();
                            }else if(!dog.isEmpty()&&str.equals(dog.peekFirst())){
                                 sb.append(str).append("\n");
                                 dog.pop();
                            }
                        }
                        break;
                    case "pollDog":
                        while(!dog.isEmpty())
                            sb.append(dog.poll()).append("\n");
                        break;
                    case "pollCat":
                         while(!cat.isEmpty())
                            sb.append(cat.poll()).append("\n");
                        break;
                    case "isEmpty":
                        if(dog.isEmpty()&&cat.isEmpty())
                            sb.append("yes");
                        else
                            sb.append("no");
                        sb.append("\n");
                        break;
                    case "isDogEmpty":
                        if(dog.isEmpty())
                            sb.append("yes");
                        else
                            sb.append("no");
                        sb.append("\n");
                        break;
                    case "isCatEmpty":
                        if(cat.isEmpty())
                            sb.append("yes");
                        else
                            sb.append("no");
                        sb.append("\n");
                        break;
                }
                
            }
            System.out.println(sb.toString());
        }
        sc.close();
    }
    
}

同样的逻辑，C++用cstdio读写的速度几乎是iostream的10倍😅

#include <queue>
#include <string>
using namespace std;

class Cat
{
public:
    Cat(int num)
    {
       m_nNumber = num; 
    }
    int GetNumber()
    {
        return m_nNumber;
    }
private:
    int m_nNumber;
};

class Dog
{
public:
    Dog(int num)
    {
       m_nNumber = num; 
    }
    int GetNumber()
    {
        return m_nNumber;
    }    
private:
    int m_nNumber;
};

class CatRecord : public Cat
{
public:
    CatRecord(int num,int index):Cat(num)
    {
        m_nIndex = index; 
    }
    int GetIndex()
    {
        return m_nIndex;
    }
private:
    int m_nIndex;
};

class DogRecord : public Dog
{
public:
    DogRecord(int num,int index):Dog(num)
    {
        m_nIndex = index; 
    }
    int GetIndex()
    {
        return m_nIndex;
    }
private:
    int m_nIndex;
};

class CatDogQueue
{
public:
    CatDogQueue()
    {
        m_nIndex = 0;
    }
    void AddCat(int number)
    {
        m_nIndex++;
        CatRecord catRec(number,m_nIndex);
        catQueue.push(catRec);
    }
    void AddDog(int number)
    {
        m_nIndex++;
        DogRecord dogRec(number,m_nIndex);
        dogQueue.push(dogRec);
    }  
    
    bool isEmpty()
    {
        return catQueue.empty() && dogQueue.empty();
    }
    bool isDogEmpty()
    {
        return dogQueue.empty();
    }
    bool isCatEmpty()
    {
        return catQueue.empty();
    }    
    void poolDog()
    {
        while(  !dogQueue.empty() )
        {
            DogRecord dogRec = dogQueue.front();
            cout << "dog " << dogRec.GetNumber() << endl;
            dogQueue.pop();
        }
    }
    void poolCat()
    {
        while(  !catQueue.empty() )
        {
            CatRecord catRec = catQueue.front();
            cout << "cat " << catRec.GetNumber() << endl;
            catQueue.pop();
        }
    }
    
    void poolAll()
    {   
        while(  !catQueue.empty() && !dogQueue.empty() )
        {
            CatRecord catRec = catQueue.front();
            DogRecord dogRec = dogQueue.front();
            if( catRec.GetIndex() < dogRec.GetIndex() )
            {
                cout << "cat " << catRec.GetNumber() << endl; 
                catQueue.pop();
            }
            else
            {
                 cout << "dog " << dogRec.GetNumber() << endl;
                 dogQueue.pop();               
            }
        }
        
        poolCat();
        poolDog();
    }    
    
private:
    queue<CatRecord> catQueue;
    queue<DogRecord> dogQueue;
    int m_nIndex;
};

int main(int argc, char* argv[])
{
    CatDogQueue cQueue;
    int lineNum = 0;
    cin >> lineNum;
    string cmd;
    while(lineNum >0)
    {
        lineNum--;
        cin >> cmd;
        if(cmd.compare("add") == 0)
        {
            string catordog;
            int number;
            cin >> catordog >> number;
            if(catordog.compare("dog")==0)
            {
                cQueue.AddDog(number);
            }
            if(catordog.compare("cat")==0)
            {
                cQueue.AddCat(number);
            }   
            continue;
        }
        if(cmd.compare("pollAll") == 0)
        {
            cQueue.poolAll();
            continue;
        }
        if(cmd.compare("pollDog") == 0)
        {
            cQueue.poolDog();
            continue;
        }
        if(cmd.compare("pollCat") == 0)
        {
            cQueue.poolCat();
            continue;
        }        
         if(cmd.compare("isDogEmpty") == 0)
        {
             if( cQueue.isDogEmpty() )
             {
                 cout << "yes" << endl;
             }
             else
             {
                 cout <<"no" << endl;
             }
            continue;
        }      
         if(cmd.compare("isCatEmpty") == 0)
        {
             if( cQueue.isCatEmpty() )
             {
                 cout << "yes" << endl;
             }
             else
             {
                 cout <<"no" << endl;
             }
            continue;
        }        
        if(cmd.compare("isEmpty") == 0)
        {
             if( cQueue.isEmpty() )
             {
                 cout << "yes" << endl;
             }
             else
             {
                 cout <<"no" << endl;
             }
            continue;
        }         
    }
    
    return 0;
}