class MyQueue {
public:
    stack<int> st1;
    stack<int> st2;
    /** Initialize your data structure here. */
    MyQueue() {

    }

    /** Push element x to the back of queue. */
    void push(int x) {
        st1.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if(st2.empty())
        {   
            while(!st1.empty())
            {
                st2.push(st1.top());
                st1.pop();
            }
        }
        int top = st2.top();
        st2.pop();
        return top;

    }

    /** Get the front element. */
    int peek() {
        if(st2.empty())
        {
            while(!st1.empty())
            {
                int top1 = st1.top();
                st1.pop();
                st2.push(top1);
            }
        }
        return st2.top();
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return (st1.empty() && st2.empty());
    }
};

我是栈1作为插入栈，栈2作为输出栈，栈2中有数据的时候需要peek或者pop直接对其操作就行，栈2为空的时候再把栈1中数据全部挪过来，这样写不用拷贝回去开销比较小，代码的话自我感觉写的和各位大佬比也比较简洁^^

这里好像没有考虑队列为空的情况

题目保证操作是有效的

请问copy函数中a.pop()是什么操作啊

弹出（删除）a的最顶部值。

题干中的MyQueue queue = new MyQueue();是不是有问题啊，我觉得是MyQueue *queue = new MyQueue();

牛

class MyQueue {
    int stack1[107];
    int stack2[107];
    int top1, top2;
public:
    /** Initialize your data structure here. */
    MyQueue() {
        top1 = top2 = -1;
    }

    /** Push element x to the back of queue. */
    void push(int x) {
        stack1[++ top1] = x;
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if (top2 == -1) {
            while (top1 >= 0) {
                stack2[++ top2] = stack1[top1 --];
            }
        }
        return stack2[top2 --];
    }

    /** Get the front element. */
    int peek() {
        if (top2 == -1) {
            while (top1 >= 0) {
                stack2[++ top2] = stack1[top1 --];
            }
        }
        return stack2[top2];
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return top1 == -1 && top2 == -1;
    }
};

class MyQueue {
public:
    stack<int> in_st, out_st;
    /** Initialize your data structure here. */
    MyQueue() {
    }

    /** Push element x to the back of queue. */
    void push(int x) {
        in_st.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        int res = INT_MIN;
        if (out_st.empty()) {
            while (!in_st.empty()) {
                out_st.push(in_st.top());
                in_st.pop();
            }
        }
        if (!out_st.empty()) {
            res = out_st.top();
            out_st.pop();
        }
        return res;
    }

    /** Get the front element. */
    int peek() {
        int res = INT_MIN;
        if (out_st.empty()) {
            while (!in_st.empty()) {
                out_st.push(in_st.top());
                in_st.pop();
            }
        }
        if (!out_st.empty()) {
            res = out_st.top();
        }
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return in_st.empty()&&out_st.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

a.top是？

栈顶元素

class MyQueue {
public:
    stack<int> s1,s2;
    /** Initialize your data structure here. */
    MyQueue() {

    }

    /** Push element x to the back of queue. */
    void push(int x) {
        s1.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if(s2.empty())
            while(s1.size()>0)
            {
                int data1 = s1.top();
                s1.pop();
                s2.push(data1);
            }
        int data2 = s2.top();
        s2.pop();
        return data2;
    }

    /** Get the front element. */
    int peek() {
        return s2.top();
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return s1.empty() && s2.empty();
    }
};

这个程序为什么会报segmentation fault的错呀

在peek函数里也需要像pop函数那样判断一下s2是否为空。另外之后有问题尽量发在问答页面，这里是集中提问的地方，曝光度更大，会更及时得获得回复。

好的

那为啥yls的代码里没有判断是否为空啊

我的代码中所有元素一直都存在stk中，他的代码里不一定都存在s2中。

因为y总的代码在模拟出队列之前能保证所有的元素都在入的那个栈中,另外在出队列完成后,又copy回去,所有在出队列后也能保证

这里自己定义的pop函数 和stack的pop函数 重名，没问题吗 y总

pop是stack的成员函数，无影响。

前面是有queue.pop()或者stack.pop()有前缀,也相当于域作用限定符限制了

我们用两个栈来做，一个负责插入，一个负责读取。

class MyQueue {
public:
    /** Initialize your data structure here. */
    MyQueue() {

    }

    /** Push element x to the back of queue. */
    void push(int x) {
        while(!s2.empty()){
            s1.push(s2.top());
            s2.pop();
        }
        s1.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        while(!s1.empty()){
            s2.push(s1.top());
            s1.pop();
        }
        if(!s2.empty()){
            int res=s2.top();
            s2.pop();
            return res;
        }
        cout<<"pop error"<<endl;
        return INT_MIN;
    }

    /** Get the front element. */
    int peek() {
        while(!s1.empty()){
            s2.push(s1.top());
            s1.pop();
        }
        if(!s2.empty()) 
            return s2.top();
        cout<<"peek error"<<endl;
        return INT_MIN;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return s1.empty() && s2.empty();
    }

    stack<int> s1,s2;
    // s1负责插入 s2负责读取
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

可以的hh

哈哈哈大佬，这个需求好不好实现，感觉更好debug：https://www.acwing.com/problem/content/discussion/content/89/