Cranking the Coding Interview: Stacks and Queues

Animal Shelter

这道题目就是使用deque再合适不过了。

不过deque的实现可以使用list来实现，这里实现的方法就是开头一个指针指向开头、一个指向结尾。

用开头的指针来做被收养的操作，如果不是符合要求的话，那么就建立一个list存储需要的内容。然后需要往收容所增加动物的时候，就把动物加在链表的后面。

具体代码实现：

class CatDogAsylum {
public:
    vector<int> asylum(vector<vector<int> > ope) {
        // write code here
        deque<int> que;
        vector<int> seq;

        int ope_size = ope.size();
        for(int i = 0; i < ope_size; i++) {
            // put animal into shelter
            if(ope[i][0] == 1) {
                que.push_back(ope[i][1]);
            }
            // adopt anmial 
            else {
                vector<int> pre;
                if(ope[i][1] == 0) {
                    seq.push_back(que.front());
                    que.pop_front();
                }
                else {
                    // adopt dog
                    if(ope[i][1] == 1) {
                        while(!que.empty()) {
                            int tp = que.front();
                            if(tp > 0) { seq.push_back(tp); que.pop_front(); break; }
                            else { que.pop_front(); pre.push_back(tp); } 
                        }   
                        if(!pre.empty()) que.insert(que.begin(), pre.begin(), pre.end());
                    } 
                    // adopt cat
                    else {
                        while(!que.empty()) {
                            int tp = que.front();
                            if(tp < 0) { seq.push_back(tp); que.pop_front(); break; }
                            else { que.pop_front(); pre.push_back(tp); } 
                        }   
                        if(!pre.empty()) que.insert(que.begin(), pre.begin(), pre.end());                       
                    }
                }
            }
        }
        return seq;
    }
};

在cc189上的代码如下：

abstract class Animal {
    private int order;
    protected String name;
    public Animal(String n) {name = n;}
    public int getOrder() {return order;}
    public boolean isOrderThan(Animal a) {
        return this.order < a.getOrder();
    }
};

class AnimalQueue{
    LinkedList<Dog> dogs = new LinkedList<Dog>();
    LinkedList<Cat> cats = new LinkedList<Cats>();
    private int oreder = 0;

    public void enqueue(Animal a) {
        a.setOrder(order);
        order++;
    }

    public Animal dequeueAny() {
        if(dogs.size() == 0) {
            return dequeueCats();
        }
        if(cats.size() == 0) {
            return dequeueDogs();
        }
        Dog dog = dog.peek();
        Cat cat = cats.peek();
        if(dog.isOrderThan(cat)) return deuqueDogs();
        else return dequeueCats();
    } 

    public Dog dequeueDogs() {
        return dogs.poll();
    }

    public Cat dequeueCats() {
        return cats.poll();
    } 
}

public class Dog extend Animal {
    public Dog(String n) {super(n);}
}

public class Cat extend Animal {
    public Cat(String n) {super(n);}
}

Queue via Stacks

这里做的就是把两个栈实现为队列，我的方法比较简单，就是使用一个栈来存数据，另外一个栈用来做中转。那么就可以写成：

class Solution
{
public:
    void push(int node) {
        if(!stack1.empty()) {
            int tmp;
            while(!stack1.empty()) {
                tmp = stack1.top();
                stack1.pop();
                stack2.push(tmp);
            }
            stack1.push(node);
            while(!stack2.empty()) {
                tmp = stack2.top();
                stack2.pop();
                stack1.push(tmp);
            }
        }   
        else stack1.push(node);
    }

    int pop() {
        if(!stack1.empty()) {int res = stack1.top(); stack1.pop(); return res;}
        else return 0;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

Three in One