01.算法總結

貓狗隊列

注意：

查找了一些網上的寫法，發現很多樣本再處理pollAll pollDog pollCat方法的時候，並不是如下邊的要求彈出所有，原因不詳，以我對文字的
敏感性來說，這種只彈出一個的方式是錯誤的，奈何很多公司的算法題
答案也是如此，所以暫且先這樣處理，你完全可以添加一個循環將所有
元素彈出

實現一種貓狗隊列的結構，要求如下：

用戶可以調用add方法將cat類或者dog類的實例放入隊列中；
用戶可以調用pollAll方法，將隊列中所有的實例按照隊列的先後順序依次彈出；
用戶可以調用pollDog方法，將隊列中dog類的實例按照隊列的先後順序依次彈出；
用戶可以調用pollCat方法，將隊列中cat類的實例按照隊列的先後順序依次彈出；
用戶可以調用isEmpty方法，檢查隊列中是否還有dog和cat的實例；
用戶可以調用isDogEmpty方法，檢查隊列中是否還有do的實例；
用戶可以調用isCatEmpty方法，檢查隊列中是否還有cat的實例。

public class CatDogQueue {
    private LinkedList<PetHolder> dogs;
    private LinkedList<PetHolder> cats;
    private int order;

    public CatDogQueue() {
        dogs = new LinkedList<>();
        cats = new LinkedList<>();
        order = 0;
    }
    public void add(Pet pet) {
        if ("cat".equals(pet.getPetType())) {
            cats.add(new PetHolder(pet, order++));
        } else if ("dog".equals(pet.getPetType())) {
            dogs.add(new PetHolder(pet, order++));
        }
    }
    public void pollAll() {
        if (!dogs.isEmpty() && !cats.isEmpty()) {
            if (dogs.peek().getOrder() < cats.peek().getOrder()) {
                dogs.poll();
            } else {
                cats.poll();
            }
        } else if (!dogs.isEmpty()) {
            dogs.poll();
        } else if (!cats.isEmpty()) {
            cats.poll();
        }
    }
    public Dog pollDog() {
        if (!dogs.isEmpty()) {
            return (Dog) dogs.poll().getPet();
        }
        return null;
    }
    public Cat pollCat() {
        if (!cats.isEmpty()) {
            return (Cat) cats.poll().getPet();
        }
        return null;
    }
    public boolean isEmpty() {
        return dogs.isEmpty() && cats.isEmpty();
    }
    public boolean isCatsEmpty() {
        return cats.isEmpty();
    }
    public boolean isDogsEmpty() {
        return dogs.isEmpty();
    }
}

class Pet {
    private String type;
    public Pet(String type) {
        this.type = type;
    }
    public String getPetType() {
        return this.type;
    }
}

class PetHolder {
    private Pet pet;
    private long order;
    public PetHolder(Pet pet, long order) {
        this.pet = pet;
        this.order = order;
    }
    public Pet getPet() {
        return this.pet;
    }
    public long getOrder() {
        return this.order;
    }
    public String getEnterPetType() {
        return this.pet.getPetType();
    }
}

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

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

用兩個棧實現隊列，支持隊列的基本操作(add,poll, peek)

簡單分析：
1.先進先出，那麼兩個棧結合剛好滿足這一點
2.兩個棧順序操作，全部添加到第一個棧之後，當要開始出的時候再往第二個棧中添加，從而保證先進先出的特性

public class QueueMadeOfStack {

    private Stack<Integer> pushStack;
    private Stack<Integer> popStack;

    public QueueMadeOfStack() {
        pushStack = new Stack<Integer>();
        popStack = new Stack<Integer>();
    }
    
    public void add(int value) {
        pushStack.push(value);
    }
    
    public int poll() {
        if(popStack.empty() && pushStack.empty()) {
            throw new RuntimeException("queue is empty");
        }else if(popStack.empty()) {    
            while(!pushStack.empty()) {
                popStack.push(pushStack.pop());
            }
        }
        return popStack.pop();
    }
    
    public int peek() {
        if(popStack.empty() && pushStack.empty()) {
            throw new RuntimeException("queue is empty");
        }else if(popStack.empty()) {    
            while(!pushStack.empty()) {
                popStack.push(pushStack.pop());
            }
        }
        return popStack.peek();
    }
}

設計一個有獲取最小值功能的棧，支持棧的基本功能，額外鄭家一個getMin方法，要求pop,push,getMin時間複雜度爲O(1)。可以使用現成的棧結構

簡單分析：需要滿足的要求大概如下：
1.先進後出
2.未進數據之前，爲空，出完數據之後爲空，所以如下實現中，pop使要保證兩個stack都要pop乾淨

public class StackGetMin {
    Stack<Integer> stack = null;
    Stack<Integer> stackMin = null;
    public StackGetMin(){
        stack = new Stack<Integer>();
        stackMin = new Stack<Integer>();
    }
    
    public int size(){
        return stack.size();
    }
    
    public int pop(){
        
        if(!stackMin.empty()){
            stackMin.pop();
        }
        if(!stack.empty()){
            return stack.pop();
        }
        return 0;
    }
    
    public void push(int i){
        stack.push(i);
        if(stackMin.empty()){
            stackMin.push(i);
        }else{
            int temp = stackMin.peek();
            if(i < temp){
                stackMin.push(i);
            }
        }
    }
    
    public int getMin(){
        if(!stackMin.empty()){
            return stackMin.peek();
        }
        return 0;
    }
}

未完，待續...