《Cracking the Coding Interview》——第3章：栈和队列——题目7

2014-03-19 03:20

题目：实现一个包含阿猫阿狗的先入先出队列，我要猫就给我一只来的最早的猫，要狗就给我一只来的最早的狗，随便要就给我一只来的最早的宠物。建议用链表实现。

解法：单链表可以实现一个简单的队列，这种有不同种类数据的队列，可以用if语句选择，也可以用一个堆做时间上的优化。对于来的时间，我用一个64位整数表示时间戳，在地球被太阳吃掉以前，这个数字是不大可能上溢的，所以问题应该不大。

代码：

 // 3.7 Implement a queue that holds cats and dogs. If you want dog or cat, you get the oldest dog or cat. If you want a pet, you get the oldest of them all.
 #include <iostream>
 #include <string>
 using namespace std;

 template <class T>
 struct ListNode {
     T val;
     long long int id;
     ListNode *next;

     ListNode(T _val = , long long int _id = ): val(_val), id(_id), next(nullptr) {};
 };

 template <class T>
 class CatsAndDogs {
 public:
     CatsAndDogs() {
         first_cat = last_cat =  first_dog = last_dog = nullptr;
         current_id = ;
     }

     void enqueue(T val, int dog_or_cat) {
         switch (dog_or_cat) {
         case :
             // cat
             if (first_cat == nullptr) {
                 first_cat = last_cat = new ListNode<T>(val, current_id);
             } else {
                 last_cat->next = new ListNode<T>(val, current_id);
                 last_cat = last_cat->next;
             }
             break;
         case :
             // dog
             if (first_dog == nullptr) {
                 first_dog = last_dog = new ListNode<T>(val, current_id);
             } else {
                 last_dog->next = new ListNode<T>(val, current_id);
                 last_dog = last_dog->next;
             }
             break;
         }
         ++current_id;
     }

     T dequeueAny() {
         if (first_cat == nullptr) {
             return dequeueDog();
         } else if (first_dog == nullptr) {
             return dequeueCat();
         } else if (first_cat->id < first_dog->id) {
             return dequeueCat();
         } else {
             return dequeueDog();
         }
     }

     T dequeueCat() {
         T result;

         result = first_cat->val;
         if (first_cat == last_cat) {
             delete first_cat;
             first_cat = last_cat = nullptr;
         } else {
             ListNode<T> *ptr = first_cat;
             first_cat = first_cat->next;
             delete ptr;
         }

         return result;
     }

     T dequeueDog() {
         T result;

         result = first_dog->val;
         if (first_dog == last_dog) {
             delete first_dog;
             first_dog = last_dog = nullptr;
         } else {
             ListNode<T> *ptr = first_dog;
             first_dog = first_dog->next;
             delete ptr;
         }

         return result;
     }
 private:
     ListNode<T> *first_cat;
     ListNode<T> *first_dog;
     ListNode<T> *last_cat;
     ListNode<T> *last_dog;
     long long int current_id;
 };

 int main()
 {
     CatsAndDogs<string> cd;
     string val;
     string type;
     string cmd;

     while (cin >> cmd) {
         if (cmd == "end") {
             break;
         } else if (cmd == "in") {
             cin >> type;
             if (type == "cat") {
                 cin >> val;
                 cd.enqueue(val, );
             } else if (type == "dog") {
                 cin >> val;
                 cd.enqueue(val, );
             }
         } else if (cmd == "out") {
             cin >> type;
             if (type == "cat") {
                 cout << "cat=" << cd.dequeueCat() << endl;
             } else if (type == "dog") {
                 cout << "dog=" << cd.dequeueDog() << endl;
             } else if (type == "any") {
                 cout << "any=" << cd.dequeueAny() << endl;
             }
         }
     }

     return ;
 }