【LeetCode栈与队列#01】队列的基本操作：用栈模拟队列和用队列模拟栈

用栈实现队列

力扣题目链接(opens new window)

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。

pop() -- 从队列首部移除元素。

peek() -- 返回队列首部的元素。

empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

• 你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
• 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

栈的基本操作

示例：

#include <stack>

//栈容器常用接口
void test01()
{
	//创建栈容器 栈容器必须符合先进后出
	stack<int> s;

	//向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		//输出栈顶元素
		cout << "栈顶元素为： " << s.top() << endl;
		//弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

• 入栈 --- push
• 出栈 --- pop
• 返回栈顶 --- top
• 判断栈是否为空 --- empty
• 返回栈大小 --- size

思路

题意是要模拟一个队列的行为，用栈

队列是什么？前后都打开的一种结构，也就是说可以实现先进先出

这点用一个栈不太好还原，所以要模拟先进先出至少得使用两个 stack ，

分别为进栈（stack_in）和出栈（stack_out）

当模拟队列 push 时，我们同样只需要将数据 push 进 stack_in 即可，该动作可以直接调用官方为stack提供的 push 函数

当模拟队列 pop 时，我们要先将 stack_in 的所有数据 pop 出来再 push 进 stack_out 。

此时，之前先进入 stack_in 的数据就在 stack_out 的 top 位置了，剩下的我们只需要对 stack_out 进行 pop 操作即可模拟队列的pop。

对应的模拟动画如下：

注意：在将 stack_in 的数据放入 stack_out 之前，必须先检查 stack_out 是否为空，不为空就直接从stack_out 往外弹数据。且往放 stack_out 数据时必须一次性全部放完，不然上述两种情况都会导致数据的顺序出错。

代码

步骤：（实现pop）

1、判断出栈是否为空

2、循环将入栈数据压入出栈

3、然后从stack_out的栈顶获取数据

class MyQueue {
public:
    //定义两个栈
    stack<int>stack_in;
    stack<int>stack_out;

    MyQueue() {

    }

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

    int pop() {
         int tmp;
        //判断stack_out是否为空，不为空就往里面不断push数据
        if(stack_out.empty()){
            //将stack_in的全部数据push入
            while(!stack_in.empty()){
                // stack_out.push(stack_in.pop()) //错误，应该让stack_out先获取stack_in的栈顶数据，然后再pop走
                // stack_out.push(stack_in.top());//虽然在本题不会报错，但
                // stack_in.pop();//这种写法会在别的同类型的题中出错，所以统一使用下面的写法
                tmp = stack_in.top();
                stack_in.pop();
                stack_out.push(tmp);
            }
        }
        //然后从stack_out获取数据
        int res = stack_out.top();
        stack_out.pop();
        return res;

    }

    int peek() {//即查看栈顶数据
        int res = this->pop();//直接复用类内的pop
        //然后记得再把数据push回来
        stack_out.push(res);
        return res;

    }

    bool empty() {
        return stack_in.empty() && stack_out.empty();
    }
};

注意点

1、对栈进行pop操作是没有返回值的，也就是说pop之后，栈顶的数据就没了，要读数据用top读

2、能复用就复用，优雅且专业

用队列实现栈

力扣题目链接(opens new window)

使用队列实现栈的下列操作：

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

注意:

• 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
• 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
• 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）

queue基本操作

示例：

#include <queue>
#include <string>
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void test01() {

	//创建队列
	queue<Person> q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);

	//向队列中添加元素  入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问
	while (!q.empty()) {
		//输出队头元素
		cout << "队头元素-- 姓名： " << q.front().m_Name
              << " 年龄： "<< q.front().m_Age << endl;

		cout << "队尾元素-- 姓名： " << q.back().m_Name
              << " 年龄： " << q.back().m_Age << endl;

		cout << endl;
		//弹出队头元素
		q.pop();
	}

	cout << "队列大小为：" << q.size() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

• 入队 --- push
• 出队 --- pop
• 返回队头元素 --- front
• 返回队尾元素 --- back
• 判断队是否为空 --- empty
• 返回队列大小 --- size

思路

用一个队列就可以模拟栈的行为

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

代码

步骤：（实现pop）

1、获取队列长度qLen

2、循环，只需循环qLen-1的部分，最后一个元素不用动。不断获取队头数据再加入队尾，然后pop调当前数据

3、循环结束后，现在队中元素的顺序就颠倒了（与栈顺序一致），接下来就从队头拿数据就行，

class MyStack {
public:
    //创建队列
    queue<int> q;

    MyStack() {

    }

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

    int pop() {
        //获取队列长度
        int qLen = q.size();
        //需要循环的部分不包含最后一个数
        qLen--;
        while(qLen--){
            //将队头的数据push到队尾
            q.push(q.front());
            //弹出当前队头数据
            q.pop();
        }
        //已获得需要的数据顺序
        //一个一个获取即可
        int res = q.front();
        q.pop();
        return res;
    }

    int top() {
        //在栈里面的第一个元素，其实就是队列的最后一个元素，用back方法可以获取到
        return q.back();
    }

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

TBD