動物收容所，先進先出

      有家動物收容所只收容狗與貓，且嚴格遵照「先進先出」原則。在收養該收容所的動物時，收養人只能收養進入收容所時間最長的動物，或者，挑選貓或狗中收養時間最長的。

請建立適合這個系統的數據結構，實現各類操做方法，好比enqueue，dequeueAny， dequeDog, dequeueCat等，容許使用Java內置的LinkedList數據結構

 

      有家動物收容所只收留貓和狗，但有特殊的收養規則，收養人有兩種收養方式，第一種爲直接收養全部動物中最先進入收容所的，第二種爲選擇收養的動物類型（貓或狗），並收養該種動物中最先進入收容所的。

題目分析：

  根據先進先出的原則，天然想到了用隊列實現，若是隻維護一個隊列，那麼第一種方法實現起來比較簡單，只須要取出隊頭的動物則能夠，可是第二種方法就比較複雜，須要訪問整個隊列來找出第一個被訪問的貓或者狗。

  所以咱們能夠選擇維護兩個隊列來實現，一個隊列存放放入的狗，一個隊列存放放入的貓，對於第二種方法實現起來至關容易，咱們只須要根據要選擇的貓或者狗從 相應的隊列中取出即可以，可是第一種方法須要判斷那個兩個隊列頭部的是貓先進入收容所，仍是狗先進入，這個時候須要一個標誌，因此咱們每次把動物放入隊列 的時候，同時將一個遞增的序號放入隊列，這個序號就是一個時間序列，根據這個序號即可以輕鬆實現第一種方法。

 

思路：

一、方法一：維護一個隊列，dequeueAny實現簡單，可是dequeueDog和dequeueDog須要迭代訪問整個隊列，才能找到第一隻該被收養的貓或狗。

 

二、方法二：

 

[java] view plain copy

 

1. /** 
2.  * 方法二：爲狗和貓各自建一個隊列，而後將二者放進名爲AnimalQueue的類中，而且存儲某種形式的時間戳，來標記每隻動物進入隊列的時間。調用dequeueAny時，查看狗隊列和貓隊列的首部，並返回最老的那一隻。 
3.  */  
4. import java.util.*;  
5.   
6. public class AnimalQueue {  
7.       LinkedList<Dog> dogs= new LinkedList<Dog>();  
8.       LinkedList<Cat> cats= new LinkedList<Cat>();  
9.       private int order=0;//時間戳  
10.   
11.       public void enqueue(Animal a){  
12.              a.setOrder( order);  
13.              order++;  
14.               
15.              if( a instanceof Dog)  
16.                    dogs.add((Dog) a);  
17.              else if( a instanceof Cat)  
18.                    cats.add((Cat) a);  
19.       }  
20.         
21.       public Animal dequeueAny(){  
22.              if( dogs.size()==0)  
23.                    return dequeueCat();  
24.              else if( cats.size()==0)  
25.                    return dequeueDog();  
26.               
27.             Dog dog= dogs.peek(); //not remove  
28.             Cat cat= cats.peek();  
29.              if( dog.isOlderThan( cat))  
30.                    return dequeueDog(); //此時須要remove，因此不能只是返回dog  
31.              else  
32.                    return dequeueCat();  
33.       }  
34.         
35.       public Dog dequeueDog(){  
36.              return dogs.poll(); //remove  
37.       }  
38.         
39.       public Cat dequeueCat(){  
40.              return cats.poll();  
41.       }  
42. }  
43.   
44. class Dog extends Animal{  
45.       public Dog(String n) {  
46.              super( n);  
47.       }       
48. }  
49.   
50. class Cat extends Animal{  
51.       public Cat(String n) {  
52.              super( n);  
53.       }       
54. }  
55.   
56. abstract class Animal{  
57.       int order;  
58.       String name;  
59.         
60.       public Animal(String n){  
61.              this. name= n;  
62.       }  
63.   
64.       public int getOrder() {  
65.              return order;  
66.       }  
67.   
68.       public void setOrder( int order) {  
69.              this. order = order;  
70.       }  
71.         
72.       public boolean isOlderThan(Animal a){  
73.              return this.getOrder()< a.getOrder();  
74.       }       
75. } 

有家動物收容所只收留貓和狗，但有特殊的收養規則，收養人有兩種收養方式，第一種爲直接收養全部動物中最先進入收容所的，第二種爲選擇收養的動物類型（貓或狗），並收養該種動物中最先進入收容所的。

       給定一個操做序列int[][2] ope(C++中爲vector<vector<int>>)表明全部事件。若第一個元素爲1，則表明有動物 進入收容所，第二個元素爲動物的編號，正數表明狗，負數表明貓；若第一個元素爲2，則表明有人收養動物，第二個元素若爲0，則採起第一種收養方式，若爲 1，則指定收養狗，若爲-1則指定收養貓。請按順序返回收養的序列。若出現不合法的操做，即沒有能夠符合領養要求的動物，則將此次領養操做忽略。

測試樣例：

[[1,1],[1,-1],[2,0],[2,-1]]

返回：[1,-1]

或者

public ArrayList<Integer> asylum(int[][] ope) {

        class Animal {

            int id, order;

 

            public Animal(int id, int order) {

                this.id = id;

                this.order = order;

            }

        }

        int order = 0;

        LinkedList<Animal> dogs = new LinkedList<>();

        LinkedList<Animal> cats = new LinkedList<>();

        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < ope.length; i++) {

            if (ope[i][0] == 1) {

                if (ope[i][1] > 0)

                    dogs.add(new Animal(ope[i][1], order++));

                else if (ope[i][1] < 0)

                    cats.add(new Animal(ope[i][1], order++));

            }

 

            else if (ope[i][0] == 2) {

                if (ope[i][1] == 0) {

                    Animal d = dogs.peek();

                    Animal c = cats.peek();

                    boolean flag = false;

                    if (d != null && c != null) {

                        if (d.order - c.order < 0)

                            flag = true;

                    } else if (d == null && c == null)

                        continue;

                    else if (d != null)

                        flag = true;

 

                    if (flag)

                        list.add(dogs.removeFirst().id);

                    else

                        list.add(cats.removeFirst().id);

                } else if (ope[i][1] == 1) {

                    if (dogs.peek() != null)

                        list.add(dogs.removeFirst().id);

                } else if (ope[i][1] == -1) {

                    if (cats.peek() != null)

                        list.add(cats.removeFirst().id);

                }

            }

        }

        return list;

    }

 

或者：

import java.util.*;

 

public class CatDogAsylum {

    public ArrayList<Integer> asylum(int[][] ope) {

        // write code here

        ArrayList<Integer> result = new ArrayList<Integer>();

        if(null==ope||ope.length<=0)

            return result;

        ArrayList<Integer> temp = new ArrayList<Integer>();

        for(int i=0;i<ope.length;i++){

            if(ope[i][0]==1){//進入

                temp.add(ope[i][1]);

            }

            if(ope[i][0]==2){//收養

                if(ope[i][1]==0&&temp.size()>0)//採用第一種收養方式

                    result.add(temp.remove(0));

                else if(ope[i][1]==-1){//指定收養貓

                    for(int j=0;j<temp.size();j++){

                        if(temp.get(j)<0){

                            result.add(temp.remove(j));

                            break;

                        }

                    }

                }

                else if(ope[i][1]==1){//指定收養狗

                    for(int k=0;k<temp.size();k++){

                        if(temp.get(k)>0){

                            result.add(temp.remove(k));

                            break;

                        }

                    }

                }

            }

        }

        return result;

    }

}