😎前言

😼前面我们相继实现了 [栈] 和 [队列]，是不是愁没有练手的地方呢？别担心，本章带大家用队列来实现一个栈！ 😽我们都知道，栈和队列可以看作为兄弟，一个后进先出(LIFO)，一个先进先出(FIFO)，他们虽有不同的性质，但总的来说还是不分家的，因为，我们既可以用队列实现栈，也可以用栈实现队列，而本章就先来带大家来了解如何使用队列来实现栈。

如何用队列实现栈？

  • 前面废话这么多，那我们该如何用队列实现栈呢？一个队列当然不行，所以这里需要两个队列来实现。

  • 用两个队列，而每一个队列都是数据先进先出，我们仔细思考栈的后进先出这一性质，如何来操作这两个队列才能达到这样的一个性质？

  • 我们可以这样操作，一开始，两个队列都为空，所以我们随便在一个队列里进数据（就是入栈），当我们要出数据时，根据栈的性质，最后进的数据要出去，也就是在进数据的那个队列里最后进的数据要出去，但由于队列的性质只能先进的先出， ==所以这里我们需要用到另外那个空的队列==：我们将已有数据的队列依次出数据，并将出的数据入到那个空的队列中，当出数据的队列中只有一个数据时停止出数据，而此时最后剩下的那个数据，就是依据栈的性质所要删除的那个数据，这时，直接将那个数据出掉并不在入入另外一个队列即可。续：我们每次出栈都需要前面的操作，这是最难理解也是最核心的一个步骤。

在这里插入图片描述

  • 当然了，入栈操作又分两种情况：第一种就是前面所说开始两个队列都为空的情况；第二种就是当一个队列不为空时，我们只需要正常的往这个有数据的队列入栈即可。

  • 此外，用队列实现一个栈，还需要有判空，取栈顶元素，栈的销毁这些功能，不过这些都是小问题，我们可以巧用轮子 ==（轮子就是我们提前已经实现好的队列的一系列功能）== 来灵活解决这些问题。

用队列实现栈

  • 这里我们直接以题目的方式来实现，题目链接：==->== 传送门 ==<-== 。

题目描述：<font color=blue size=4>请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。</font> 在这里插入图片描述 在这里插入图片描述 在这里插入图片描述

该题提供的需要我们实现的接口：

typedef struct {

} MyStack;


MyStack* myStackCreate() {

}

void myStackPush(MyStack* obj, int x) {

}

int myStackPop(MyStack* obj) {

}

int myStackTop(MyStack* obj) {

}

bool myStackEmpty(MyStack* obj) {

}

void myStackFree(MyStack* obj) {

}
  • 由于这里我们用C语言实现，因此需要 “造轮子”，也就是将之前实现过的队列拷贝过去。

接下来，就是对栈的一系列功能接口的实现了：

<font color=green size=5>1.</font>

  • 首先当然是造轮子，有了轮子，我们对队列的一系列操作，只需要调用我们已经实现好的函数接口即可。

  • 我们将之前写的队列直接拷贝过来，拷贝的代码如下：

// 队列的数据的类型
typedef int QDataType;
// 节点结构	
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

// 队列结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

// 初始化队列
void QInit(Que* pq);
// 销毁队列
void QDestroy(Que* pq);
// 数据入队列
void QPush(Que* pq, QDataType x);
// 数据出队列
void QPop(Que* pq);
// 获取队列中有效元素个数
int QSize(Que* pq);
// 队列判空
bool QEmpty(Que* pq);
// 取队头数据
QDataType QFront(Que* pq);
// 取队尾数据
QDataType QBack(Que* pq);

// 初始化队列
void QInit(Que* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

// 队列销毁
void QDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

// 数据入队列
void QPush(Que* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	if (pq->size == 0) pq->head = pq->tail = newnode;
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}
// 数据出队列 
void QPop(Que* pq)
{
	assert(pq && !QEmpty(pq));

	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QNode* tmp = pq->head->next;
		free(pq->head);
		pq->head = tmp;
	}

	pq->size--;
}

// 获取队列中有效元素个数
int QSize(Que* pq)
{
	assert(pq);
	return pq->size;
}
// 队列判空
bool QEmpty(Que* pq)
{
	assert(pq);
	return pq->size == 0;
}

// 取队头数据
QDataType QFront(Que* pq)
{
	assert(pq && !QEmpty(pq));
	return pq->head->data;
}
// 取队尾数据
QDataType QBack(Que* pq)
{
	assert(pq && !QEmpty(pq));
	return pq->tail->data;
}

<font color=green size=5>2.</font>

  • 有了轮子之后，就是对栈的结构体的创建了，由于栈是由两个队列实现的，因此栈的结构体的成员也是两个队列：

<font color=red>相关代码实现：</font>

// 匿名结构体
typedef struct {
    Que q1;
    Que q2;
} MyStack;   // 重命名为MyStack

<font color=green size=5>3.</font>

  • 然后是创建一个栈，就是开辟一个栈的空间，其间包含对栈里的两个队列的初始化操作。

<font color=red>相关代码实现：</font>

MyStack* myStackCreate() {
	// 开辟一个栈空间
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
	assert(obj);

	// 对栈的两个成员队列调用队列的初始化函数接口初始化
	QInit(&obj->q1);
	QInit(&obj->q2);

	// 最后返回指向栈空间地址的指针
	return obj;
}

<font color=green size=5>4.</font>

  • 接着就是对入栈操作的实现。

  • 前面已经说过，如果开始两个队列都为空，随便入一个就好，后面往有数据的那个队列入即可。

<font color=red>相关代码实现：</font>

void myStackPush(MyStack* obj, int x) {
	// 开始都为空，随便入，后面往不空的入
	if (!QEmpty(&obj->q1)) QPush(&obj->q1, x);
	else QPush(&obj->q2, x);

}

<font color=green size=5>5.</font>

  • 再接着就是最复杂的出栈操作。

  • 由前面的介绍，我们已经知道了思路，而现在最主要的，就是如何判断那个队列为空。

  • 我们首先假设q1为空q2不为空，然后判断一下q1是不是真的为空，如果是，什么事没有，如果不是，就换一下，变成q2为空，q1不为空，思路就是这样，具体还需看代码。

  • 知道谁为空谁不为空后，接下来就是前面所说的思路的操作了。

<font color=red>相关代码实现：</font>

int myStackPop(MyStack* obj) {
	assert(!myStackEmpty(obj));
	
	// 假定q1为空，q2不为空
	Que* emptyQ = &obj->q1;
	Que* nonemptyQ = &obj->q2;
	
	// 判断q1是否真的为空，不为空则进去if，交换“身份”
	if (!QEmpty(emptyQ))
	{
		emptyQ = &obj->q2;
		nonemptyQ = &obj->q1;
	}
	
	// 然后就是前面所说的操作
	// 不为空的依次出队列，并将出队列的数据入到空的队列中
	// 直到出的还剩一个数据停止
	while (QSize(nonemptyQ) > 1)
	{
		int front = QFront(nonemptyQ);
		QPush(emptyQ, front);
		QPop(nonemptyQ);
	}
	
	// 最后将最后一个数据存起来
	int front = QFront(nonemptyQ);
	// 删除这个数据
	QPop(nonemptyQ);
	// 在返回存的这个数据
	return front;
}

<font color=green size=5>6.</font>

  • 当然还有获取栈顶数据的功能。

  • 我们先找到不为空的那个队列，然后调用其获取队尾数据的函数，最后将这个函数返回的结果返回即可。

<font color=red>相关代码实现：</font>

int myStackTop(MyStack* obj) {
	assert(!myStackEmpty(obj));

	if (!QEmpty(&obj->q1)) return QBack(&obj->q1);
	else return QBack(&obj->q2);
}

<font color=green size=5>7.</font>

  • 论栈的功能怎么能少得了判空呢。

  • 对于该栈的判空，我们实际上只需要判断那两个队列是否为空即可。

<font color=red>相关代码实现：</font>

bool myStackEmpty(MyStack* obj) {
	return QEmpty(&obj->q2) && QEmpty(&obj->q1);
}

<font color=green size=5>8.</font>

  • 最后就是栈的销毁了。

  • 将两个队列销毁（调用自己的销毁函数），然后将栈销毁即可。

<font color=red>相关代码实现：</font>

void myStackFree(MyStack* obj) {
	QDestroy(&obj->q1);
	QDestroy(&obj->q2);
	free(obj);
}

整体的实现代码

// 队列的数据的类型
typedef int QDataType;
// 节点结构	
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

// 队列结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

// 初始化队列
void QInit(Que* pq);
// 销毁队列
void QDestroy(Que* pq);
// 数据入队列
void QPush(Que* pq, QDataType x);
// 数据出队列
void QPop(Que* pq);
// 获取队列中有效元素个数
int QSize(Que* pq);
// 队列判空
bool QEmpty(Que* pq);
// 取队头数据
QDataType QFront(Que* pq);
// 取队尾数据
QDataType QBack(Que* pq);

// 初始化队列
void QInit(Que* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

// 队列销毁
void QDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

// 数据入队列
void QPush(Que* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	if (pq->size == 0) pq->head = pq->tail = newnode;
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}
// 数据出队列 
void QPop(Que* pq)
{
	assert(pq && !QEmpty(pq));

	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QNode* tmp = pq->head->next;
		free(pq->head);
		pq->head = tmp;
	}

	pq->size--;
}

// 获取队列中有效元素个数
int QSize(Que* pq)
{
	assert(pq);
	return pq->size;
}
// 队列判空
bool QEmpty(Que* pq)
{
	assert(pq);
	return pq->size == 0;
}

// 取队头数据
QDataType QFront(Que* pq)
{
	assert(pq && !QEmpty(pq));
	return pq->head->data;
}
// 取队尾数据
QDataType QBack(Que* pq)
{
	assert(pq && !QEmpty(pq));
	return pq->tail->data;
}

typedef struct {
    Que q1;
    Que q2;
} MyStack;

bool myStackEmpty(MyStack* obj);

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
	assert(obj);

	QInit(&obj->q1);
	QInit(&obj->q2);

	return obj;
}

void myStackPush(MyStack* obj, int x) {

	if (!QEmpty(&obj->q1)) QPush(&obj->q1, x);
	else QPush(&obj->q2, x);

}

int myStackPop(MyStack* obj) {
	assert(!myStackEmpty(obj));

	Que* emptyQ = &obj->q1;
	Que* nonemptyQ = &obj->q2;

	if (!QEmpty(emptyQ))
	{
		emptyQ = &obj->q2;
		nonemptyQ = &obj->q1;
	}

	while (QSize(nonemptyQ) > 1)
	{
		int front = QFront(nonemptyQ);
		QPush(emptyQ, front);
		QPop(nonemptyQ);
	}

	int front = QFront(nonemptyQ);
	QPop(nonemptyQ);
	return front;
}

int myStackTop(MyStack* obj) {
	assert(!myStackEmpty(obj));

	if (!QEmpty(&obj->q1)) return QBack(&obj->q1);
	else return QBack(&obj->q2);
}

bool myStackEmpty(MyStack* obj) {
	return QEmpty(&obj->q2) && QEmpty(&obj->q1);
}

void myStackFree(MyStack* obj) {
	QDestroy(&obj->q1);
	QDestroy(&obj->q2);
	free(obj);
}

😎写在最后

💝学会了用队列实现栈，那么下一篇文章就是教大家如何用栈实现队列了。栈和队列还真是有趣呢！ ❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！

<font color=blue size=4>感谢阅读本小白的博客，错误的地方请严厉指出噢~</font>