第一章 栈和队列（猫狗队列）

class Pet {

    private String type;

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

class Dog extends Pet {

    public Dog() {
        super("dog");
    }
}

class Cat extends Pet {

    public Cat() {
        super("cat");
    }
}

实现一种猫狗队列的结构，要求如下： 
1、用户可以调用add方法将cat类或者dog类的实例放入队列中；
2、用户可以调用pollAll方法，将队列中所有的实例按照队列的先后顺序依次弹出；
3、用户可以调用pollDog方法，将队列中dog类的实例按照队列的先后顺序依次弹出；
4、用户可以调用pollCat方法，将队列中cat类的实例按照队列的先后顺序依次弹出；
5、用户可以调用isEmpty方法，检查队列中是否还有dog和cat的实例；
6、用户可以调用isDogEmpty方法，检查队列中是否还有dog的实例；
7、用户可以调用isCatEmpty方法，检查队列中是否还有cat的实例。

思路：猫和狗两个队列，设计一个类DogAndCat，用于记录放入队列的每个元素的时间戳，取出时按时间戳来判断从dog队列或cat队列取出元素

代码如下：

package base;

import java.util.Stack;

public class DogAndCatQueue {
    public Stack<DogAndCat> dogs;
    public Stack<DogAndCat> cats;
    public Integer count;

    public DogAndCatQueue() {
        dogs = new Stack<DogAndCat>();
        cats = new Stack<DogAndCat>();
        count = 0;
    }

    public void push(Stack<DogAndCat> stack, DogAndCat dogAndCat) {
        stack.push(dogAndCat);
        Stack<DogAndCat> temp = new Stack<DogAndCat>();
        while (!stack.isEmpty()) {
            temp.push(stack.pop());
        }
        while (!temp.isEmpty()) {
            stack.push(temp.pop());
        }
    }

    public void add(Pet pet) throws Exception {
        if (pet.getType().equals("dog")) {
            push(dogs, new DogAndCat(pet, count++));
        } else if (pet.getType().equals("cat")) {
            push(cats, new DogAndCat(pet, count++));
        } else {
            throw new Exception("不支持的宠物类型");
        }
    }

    public Pet pollAll() throws Exception {
        if (dogs.isEmpty() && cats.isEmpty()) {
            throw new Exception("队列为空");
        }
        Pet pet = null;
        if (!dogs.isEmpty() && !cats.isEmpty()) {
            if (dogs.peek().getCount() < cats.peek().getCount()) {
                pet = dogs.pop().getPet();
            } else {
                pet = cats.pop().getPet();
            }
        } else if (!dogs.isEmpty()) {
            pet = dogs.pop().getPet();
        } else {
            pet = cats.pop().getPet();
        }
        return pet;
    }

    public Pet pollDog() throws Exception {
        if (dogs.isEmpty()) {
            throw new Exception("队列为空");
        }
        return dogs.pop().getPet();
    }

    public Pet pollCat() throws Exception {
        if (cats.isEmpty()) {
            throw new Exception("队列为空");
        }
        return cats.pop().getPet();
    }

    public boolean isEmpty() {
        return dogs.isEmpty() && cats.isEmpty();
    }

    public boolean isDogEmpty() {
        return dogs.isEmpty();
    }

    public boolean isCatEmpty() {
        return cats.isEmpty();
    }

    public static void main(String[] args) throws Exception {
        DogAndCatQueue dogAndCatQueue = new DogAndCatQueue();
        dogAndCatQueue.add(new Dog());
        dogAndCatQueue.add(new Dog());
        dogAndCatQueue.add(new Cat());
        dogAndCatQueue.add(new Dog());
        dogAndCatQueue.add(new Cat());
        dogAndCatQueue.add(new Cat());
        dogAndCatQueue.add(new Cat());
        dogAndCatQueue.add(new Dog());
        dogAndCatQueue.add(new Dog());

        while (!dogAndCatQueue.isDogEmpty()){
            System.out.println(dogAndCatQueue.pollDog().getType());
        }
    }
}

class DogAndCat {

    private Pet pet;

    private Integer count;

    public DogAndCat(Pet pet, Integer count) {
        this.pet = pet;
        this.count = count;
    }

    public Pet getPet() {
        return pet;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }
}