225. Implement Stack using Queues + 232. Implement Queue using Stacks

▶ 栈和队列的相互表示。发现内置的队列和栈结构都十分高效，相互表示后性能损失都很小。

▶ 第 225 题，用队列实现栈

● 自己的代码，3 ms，单队列实现，入栈 O(1)，读取栈顶元素 O(n)，出栈 O(n) 。

 class MyStack
 {
 private:
     queue<int> fakeStack;
 public:
     MyStack()
     {
         fakeStack = queue<int>();
     }
     void push(int x)
     {
         fakeStack.push(x);
     }
     int pop()
     {
         if (fakeStack.empty())
             return -;
         int i, output;
         if (fakeStack.size() == )
         {
             output = fakeStack.front();
             fakeStack.pop();
             return output;
         }
         for (i = ;; i++)
         {
             output = fakeStack.front(), fakeStack.pop();
             if (i == fakeStack.size())// 注意这里 fakeStack.size() 已经发生了改变，不用再 -1 了
                 return output;
             else
                 fakeStack.push(output);
         }
     }
     int top()
     {
         if (fakeStack.empty())
             return -;
         if (fakeStack.size() == )
             return fakeStack.front();
         int i, output;
         for (i = ;; i++)
         {
             output = fakeStack.front(), fakeStack.pop();
             fakeStack.push(output);
             if (i == fakeStack.size() - )
                 return output;
         }
     }
     bool empty()
     {
         return fakeStack.empty();
     }
 };

● 大佬的代码，3 ms，队列 queue 具有成员函数 back()，可以用于读取队尾元素。单队列实现，入栈 O(1)，读取栈顶元素 O(1)，出栈 O(n) 。

 class MyStack
 {
     int curr_size;
     queue<int> q1, q2;
 public:
     MyStack()
     {
         curr_size = ;
     }
     void push(int x)
     {
         q1.push(x);
         curr_size++;
     }
     int pop()
     {
         if (q1.empty())
             return -;
         while (q1.size() != )
         {
             q2.push(q1.front());
             q1.pop();
         }
         int temp = q1.front();
         q1.pop();
         curr_size--;
         queue<int> q = q1;
         q1 = q2;
         q2 = q;
         return temp;
     }
     int top()
     {
         return q1.back();
     }
     bool empty()
     {
         return q1.empty();
     }
 };

● 作弊，就使用内置栈结构，

 class MyStack
 {
 private:
     stack<int> st;
 public:
     MyStack()
     {
         st = stack<int>();
     }
     void push(int x)
     {
         st.push(x);
     }
     int pop()
     {
         int output = st.top();
         st.pop();
         return output;
     }
     int top()
     {
         return st.top();
     }
     bool empty()
     {
         return st.empty();
     }
 };

▶ 第 232 题，用栈实现队列

● 自己的解法，2 ms，双栈实现，分别命名为 fakeQueueIn 和 fakeQueueOut，使用一个标记 store 来记录数据存放于哪个栈里，需要入队的时候把数据倒进 fakeQueueIn 中，需要读取队头或者出队的时候把数据倒入 fakeQueueOut 中，其他情况下不再调整数据的存放位置。

 class MyQueue
 {
 private:
     stack<int> fakeQueueIn,fakeQueueOut;
     bool store;                         // true：数据存储在 fakeQueueIn 中
     void moveBetweenStack(stack<int>& in, stack<int>& out)
     {
         int temp;
         for (; !in.empty(); out.push(in.top()), in.pop());
     }
 public:
     MyQueue()
     {
         fakeQueueIn = stack<int>();
         fakeQueueOut = stack<int>();
         store = true;
     }
     void push(int x)
     {
         if (!store)
         {
             moveBetweenStack(fakeQueueOut, fakeQueueIn);
             store = true;
         }
         fakeQueueIn.push(x);
     }
     int pop()
     {
         int output;
         if (store)
         {
             moveBetweenStack(fakeQueueIn, fakeQueueOut);
             store = false;
         }
         output = fakeQueueOut.top();
         fakeQueueOut.pop();
         return output;
     }
     int peek()
     {
         if (store)
         {
             moveBetweenStack(fakeQueueIn, fakeQueueOut);
             store = false;
         }
         return fakeQueueOut.top();
     }
     bool empty()
     {
         return fakeQueueIn.empty() && fakeQueueOut.empty();
     }
 };

● 最快的解法，2 ms，压根没用 stack，用的 list

 class MyQueue
 {
 public:
     list<int> data;
     list<int> buffer;
     int dataSize;
     MyQueue() : data{}, buffer{}, dataSize{  } {}
     void push(int x) {
         if (dataSize == )
             data.push_back(x);
         else
             buffer.push_back(x);
         ++dataSize;
     }
     int pop()
     {
         --dataSize;
         auto res = data.back();
         data.pop_back();
         if (data.empty())
         {
             while (!buffer.empty())
             {
                 data.push_back(buffer.back());
                 buffer.pop_back();
             }
         }
         return res;
     }
     int peek()
     {
         return data.back();
     }
     bool empty()
     {
         return dataSize == ;
     }
 };

● 作弊，使用内置的队列结构，3 ms

 class MyQueue
 {
 private:
     queue<int> qq;
 public:
     MyQueue()
     {
         qq = queue<int>();
     }
     void push(int x)
     {
         qq.push(x);
     }
     int pop()
     {
         int output = qq.front();
         qq.pop();
         return output;
     }
     int peek()
     {
         return qq.front();
     }
     bool empty()
     {
         return qq.empty();
     }
 };