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 -1;
        int i, output;
        if (fakeStack.size() == 1)
        {
            output = fakeStack.front();
            fakeStack.pop();
            return output;
        }        
        for (i = 0;; 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 -1;
        if (fakeStack.size() == 1)
            return fakeStack.front();
        int i, output;
        for (i = 0;; i++)
        {
            output = fakeStack.front(), fakeStack.pop();
            fakeStack.push(output);
            if (i == fakeStack.size() - 1)
                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 = 0;
    }
    void push(int x)
    {
        q1.push(x);
        curr_size++;
    }    
    int pop()
    {
        if (q1.empty())
            return -1;
        while (q1.size() != 1)
        {
            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{ 0 } {}
    void push(int x) {
        if (dataSize == 0)
            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 == 0;
    }
};

● 作弊，使用内置的队列结构，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();
    }
};