4、猫狗队列

题目

宠物、狗和猫的类如下：

public class Pet {
    private String type;

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

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

public class Dog extends Pet {
    public Dog() {
        super("dog");
    }
}

public class Cat extends Pet {
    public Cat() {
        super("cat");
    }
}

实现一种猫狗队列的结构，要求如下：

• 用户可以调用add方法将cat类或者dog类的实例放入队列；
• 用户可以调用pollAll方法，将队列中所有的实例按照队列的先后顺序依次弹出；
• 用户可以调用pollDog方法，将队列中所有的dog类实例按照队列的先后顺序依次弹出；
• 用户可以调用pollCat方法，将队列中的所有cat类实例按照队列的先后顺序依次弹出；
• 用户可以调用isEmpty方法，检查队列中是否还有dog类或cat类实例；
• 用户可以调用isDogEmpty方法，检查队列中是否还有dog类实例；
• 用户可以调用isCatEmpty方法，检查队列中是否还有cat类实例；

解法

这种特殊的队列需要dog队列和cat队列分别存储，通过记录实例的进队编号来存储整个队列的进队顺序。
首先定义队列中的元素petQueueElement，元素存储实例以及编号。

public class PetQueueElement {
    private Pet pet;
    private long i;

    public PetQueueElement(Pet element, long i) {
        this.pet = element;
        this.i = i;
    }

    public Pet getPet() {
        return this.pet;
    }

    public long getI() {
        return this.i;
    }

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

分别定义dogQ队列以及catQ队列，实现题目要求的7种操作。

import java.util.LinkedList;
import java.util.Queue;

public class CatDogQueue {
    private Queue<PetQueueElement> dogQ;
    private Queue<PetQueueElement> catQ;
    private long count;

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

    public void add(Pet pet) {
        if(pet.getPetType().equals("dog")){
            this.dogQ.add(new PetQueueElement(pet, this.count++));
        }else if(pet.getPetType().equals("cat")){
            this.catQ.add(new PetQueueElement(pet, this.count++));
        }else{
            throw new RuntimeException("Element is not cat or dog!");
        }
    }

    public Pet pollAll() {
        if(!this.dogQ.isEmpty() && !this.catQ.isEmpty()){
            if(this.dogQ.peek().getI() > this.catQ.peek().getI()){
                return this.catQ.poll().getPet();
            }else{
                return this.dogQ.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("Your queue is empty!");
        }
    }

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

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

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

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

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

测试

public class a1_b4_catDogQueue {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        Cat cat2 = new Cat();
        Cat cat3 = new Cat();
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
        Dog dog3 = new Dog();
        CatDogQueue catDogQueue = new CatDogQueue();
        catDogQueue.add(cat1);
        catDogQueue.add(dog1);
        catDogQueue.add(cat2);
        System.out.println(catDogQueue.pollAll().getPetType());
        System.out.println(catDogQueue.pollAll().getPetType());
        System.out.println(catDogQueue.isDogEmpty());
        System.out.println(catDogQueue.isEmpty());
        System.out.println(catDogQueue.pollAll().getPetType());
    }
}