《Coding Interview Guide · 栈和队列》猫狗队列

猫狗队列

【题目】
宠物、狗和猫的类如下：

  class Pet {
        private String type;
    
        public Pet(String type){
            this.type = type;
        }
        public String getPetType(){
            return this.type;
        }
    }
    
    class Dog extends Pet{
        public Dog(){
            super("dog");
        }
    }
    
    class Cat extends Pet{
        public Cat(){
            super("cat");
        }
    }

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

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

【思路】
以时间戳的方法区分猫狗的进入顺序，分别在DogCatQueue中创建两个Pet子类队列（Cat，Dog），在添加猫狗实体时，将时间戳加一，在弹出时，比较队列peek()中时间戳，选择弹出哪个队列中的实体对象。

    package com.javaman.chap1;
    
    
    import java.util.LinkedList;
    import java.util.Queue;
    import java.util.Scanner;
    
    public class CatDog{
        public static void main(String[]args){
            Scanner in = new Scanner(System.in);
            DogCatQueue dogCatQueue = new DogCatQueue();
    
            int n = in.nextInt();
            for(int i=1 ;i<=n;++i){
                String temp = in.next();
                if(temp.equals("cat")){
                    dogCatQueue.add(new Cat());
                }else if(temp.equals("dog")){
                    dogCatQueue.add(new Dog());
                }
            }
            while (!dogCatQueue.isEmpty()){
                System.out.println(dogCatQueue.pollAll().toString());
            }
        }
    }
    
    class Pet {
        private String type;
    
        public Pet(String type){
            this.type = type;
        }
        public String getPetType(){
            return this.type;
        }
    }
    
    class Dog extends Pet{
        public Dog(){
            super("dog");
        }
    }
    
    class Cat extends Pet{
        public Cat(){
            super("cat");
        }
    }
    
    class PetEnterQueue{
        private Pet pet;
        private long count;
    
        public PetEnterQueue(Pet pet,long count){
            this.pet = pet;
            this.count = count;
        }
    
        public Pet getPet(){
            return this.pet;
        }
    
        public long getCount(){
            return this.count;
        }
    
        public String getEnterPetType(){
            return this.pet.getPetType();
        }
    }
    
    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,count++));
            }else{
                throw new RuntimeException("err,not cat or dog");
            }
        }
    
        public Pet pollAll(){
            if(!this.dogQ.isEmpty()&&!this.catQ.isEmpty()){
                if(this.dogQ.peek().getCount()<this.catQ.peek().getCount()){
                    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("err,quwuw is empty");
            }
        }
    
        public Dog pollDog(){
            if(!this.dogQ.isEmpty()){
                return (Dog)this.dogQ.poll().getPet();
            }else {
                throw new RuntimeException("Dog queue is empty");
            }
        }
    
        public Cat pollCat(){
            if(!this.catQ.isEmpty()){
                return (Cat) this.catQ.poll().getPet();
            }else {
                throw new RuntimeException("Cat quque is empty");
            }
        }
    
        public boolean isEmpty(){
            return this.dogQ.isEmpty()&&this.catQ.isEmpty();
        }
    
        public boolean isDogQueueEmpty(){
            return this.dogQ.isEmpty();
        }
    
        public boolean isCatQueueEmpty(){
            return this.catQ.isEmpty();
        }
    }

【总结】
存储同一父类的不同子类实体时，可以创建不同的子类队列进行存储，利用时间戳等进行状态标注，在弹出时，返回值可以为同一父类类型。当弹出特定子类对象时，可以进行向下转型。