一、题目

在这里插入图片描述

二、解法

思路分析：第一种解法是利用两个队列，一个用作输出队列，一个用作备份队列。主要难点在于pop函数的实现：先将que1除了最后面元素以外的元素全部复制到que2中，然后pop que1最后面的元素，再将其他元素从que2重新复制到que1中来。
程序如下：

// 用两个队列实现栈
class MyStack{
public:
    queue<int> que1;    // 输出队列
    queue<int> que2;    // 备份队列
    MyStack() { // 构造函数

    }

    void push(int x) {
        que1.push(x);
    }

    int pop() {
        int size = que1.size();
        size--;
        while (size--) {
            que2.push(que1.front());    // 将que1队列里的除了队尾元素以外的元素全部复制到que2中
            que1.pop();
        }
        int res = que1.front();         // 然后输出que1队尾元素
        que1.pop();
        que1 = que2;                    //再将que2元素全部复制回que1        
        while (!que2.empty()) {
            que2.pop();
        }
        return res;
    }

    int top() {
        return que1.back();
    }

    bool empty() {
        return que1.empty();
    }
};

复杂度分析：

时间复杂度： pop函数是 $O (n)$ ，其他函数为 $O (1)$ 。
空间复杂度： $O (n)$ 。

另外一种解法是只使用一个队列实现。主要思想是在push时，将元素排列好，队尾最后一个元素以外的元素出队，然后在入队，这样一来，队尾的最后一个元素就在队头，实现了栈后进先出的原理。

// 用一个队列实现栈
class MyStack {
public:
    queue<int> que;     // 输出队列
    MyStack() {         // 构造函数

    }
    void push(int x) {
        que.push(x);
        // 将队列按后进在前的顺序排好，然后队列是在前的元素先出，实现栈后进先出的原理
        for (int i = 0; i < que.size() - 1; i++) {
            que.push(que.front());      // 入队
            que.pop();                  // 出队
        }
    }
    int pop() {
        int res = que.front();
        que.pop();
        return res;
    }
    int top() {
        return que.front();
    }
    bool empty() {
        return que.empty();
    }
};

复杂度分析：

时间复杂度： push函数是 $O (n)$ ，其他函数为 $O (1)$ 。
空间复杂度： $O (n)$ 。

三、完整代码

# include <iostream>
# include <queue>
using namespace std;

 用两个队列实现栈
//class MyStack{
//public:
//    queue<int> que1;    // 输出队列
//    queue<int> que2;    // 备份队列
//    MyStack() { // 构造函数
//
//    }
//
//    void push(int x) {
//        que1.push(x);
//    }
//
//    int pop() {
//        int size = que1.size();
//        size--;
//        while (size--) {
//            que2.push(que1.front());    // 将que1队列里的除了队尾元素以外的元素全部复制到que2中
//            que1.pop();
//        }
//        int res = que1.front();         // 然后输出que1队尾元素
//        que1.pop();
//        que1 = que2;                    //再将que2元素全部复制回que1        
//        while (!que2.empty()) {
//            que2.pop();
//        }
//        return res;
//    }
//
//    int top() {
//        return que1.back();
//    }
//
//    bool empty() {
//        return que1.empty();
//    }
//};

// 用一个队列实现栈
class MyStack {
public:
    queue<int> que;     // 输出队列
    MyStack() {         // 构造函数

    }
    void push(int x) {
        que.push(x);
        // 将队列按后进在前的顺序排好，然后队列是在前的元素先出，实现栈后进先出的原理
        for (int i = 0; i < que.size() - 1; i++) {
            que.push(que.front());      // 入队
            que.pop();                  // 出队
        }
    }
    int pop() {
        int res = que.front();
        que.pop();
        return res;
    }
    int top() {
        return que.front();
    }
    bool empty() {
        return que.empty();
    }
};

int main()
{
    MyStack* obj = new MyStack();
    obj->push(10);
    obj->push(20);
    int param_2 = obj->pop();
    cout << "param_2:" << param_2 << endl;
    int param_3 = obj->top();
    cout << "param_3:" << param_3 << endl;
    bool param_4 = obj->empty();
    cout << "param_4:" << param_4 << endl;
    system("pause");
    return 0;
}