【LeetCode】数据结构题解（11）[用队列实现栈]

所属专栏：玩转数据结构题型❤️
>博主首页：初阳785❤️
>代码托管：chuyang785❤️
>感谢大家的支持，您的点赞和关注是对我最大的支持！！！❤️
>博主也会更加的努力，创作出更优质的博文！！❤️
>关注我，关注我，关注我，重要的事情说三遍！！！！！！！！❤️

1.题目来源

LeetCode用队列实现栈
注意：本题涉及到有关数据结构——队列和栈，这两章节的知识点，如有小伙伴还不熟栈的，可以先复习复习一下有关栈的相关知识，复习的地方我也提供了哦，所用到的知识点——栈，所用到的知识点——队列
注意：同样的本题是使用纯C语言实现的.

2.题目描述

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
1.void push(int x) 将元素 x 压入栈顶。
2.int pop() 移除并返回栈顶元素。
3.int top() 返回栈顶元素。
4.boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

• 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

3.解题思路

• 从题目要求我们知道，要用两个队列实现栈的功能，这个就是用队列实现栈
• 开始做题之前我们首要的是明白队列和栈的特点。这里我们就简单的提一下，具体的知识请看上述给的链接。队列——队列的特性是先进的先出，就跟食堂打饭一样，先到的先打饭，打完饭就可以走了。栈——栈的特性是先进的后出，就跟我们在桌子上叠书一样，想要拿到最底下的书就要先把最上面的书先拿走。
• 搞清楚特性之后，我们就可以开始分析了。首先无论是队列还是栈，插入数据都是往尾插入的，关键就是怎么使用队列实现栈的尾删。我们知道队列删除是头删，同样可以拿到头的数据，而且我们有两个队列，我们能不能先把第一个队列的（n-1）个数据放到另一个队列里面，再把最后剩下的那个数据删除，这个样子就实现了栈的尾删。那既然有两个队列，怎么知道数据从那个队列放到那个队列里面去呢？这个简单只要判断两个队列那个为空，另一个数据不为空，就把数据放到为空的队列中去。

• 同时解释一下我们oj刷题的时出现的一些一些疑问

typedef struct {

} MyStack;

MyStack* myStackCreate() {

}

这个是我们题目出现的函数接口，我来解释一下表示什么意思。

1. 题目已经明确我们要使用两个队列来实现栈，所有我们就得创建两个队列的，而我们通常遇到这种两个及以上的要使用的成员时，为了减少传递的参数，以及代码的可读性，简洁性，我们通常会用一个结构体把他们封装起来，所以我们的上述结构体就是用来创建两个队列的，并且这个结构体还是个匿名结构体，匿名结构体的特点就是只能用一次，这里我们只需要使用一次即可，所以匿名合理。
2. 而另一个函数接口是用来初始化我们的结构体的，并返回结构体指针。

4.代码展示

//队列函数接口
typedef int QueueDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QueueDataType data;
}QNode;

typedef struct Node
{
	QNode* head;
	QNode* tail;
	int size;
}Node;

void QueueInit(Node* pq);
void QueueDestroy(Node* pq);
void QueuePushu(Node* pq, QueueDataType x);
void QueuePop(Node* pq);
QueueDataType QueueFindFront(Node* pq);
QueueDataType QueueFindBack(Node* pq);
bool QueueEmpt(Node* pq);
int QueueSize(Node* pq);

void QueueInit(Node* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Node* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->tail = pq->head = NULL;
	pq->size = 0;
}
void QueuePushu(Node* pq, QueueDataType x)
{
	assert(pq);
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->tail = pq->head = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
	pq->size++;
}
void QueuePop(Node* pq)
{
	assert(pq);
	assert(!QueueEmpt(pq));

	Node* next = pq->head->next;
	free(pq->head);
	pq->head = next;

	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
	pq->size--;
}
QueueDataType QueueFindFront(Node* pq)
{
	assert(pq);
	assert(!QueueEmpt(pq));

	return pq->head->data;
}
QueueDataType QueueFindBack(Node* pq)
{
	assert(pq);
	assert(!QueueEmpt(pq));

	return pq->tail->data;
}
bool QueueEmpt(Node* pq)
{
	assert(pq);
	
	return pq->head == NULL;
}
int QueueSize(Node* pq)
{
	assert(pq);
	return pq->size;
}



//函数实现
typedef struct {
    //创建两个队列
    Node q1;
    Node q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* ret = (MyStack*)malloc(sizeof(MyStack));
    //初始化队列
    QueueInit(&ret->q1);
    QueueInit(&ret->q2);
    //返回结构体指针
    return ret;
}

void myStackPush(MyStack* obj, int x) {
    //判断那个队列不为空，遍插入数据
    if (!QueueEmpt(&obj->q1))
    {
        QueuePushu(&obj->q1,x);
    }
    else
    {
        QueuePushu(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    //判断那个为空，（n-1）个数据放到空的队列中
    Node* empt = &obj->q1;
    Node* noEmpt = &obj->q2;
    if (!QueueEmpt(&obj->q1))
    {
        noEmpt = &obj->q1;
        empt = &obj->q2;
    }

    while (QueueSize(noEmpt)>1)
    {
        QueuePushu(empt,QueueFindFront(noEmpt));
        QueuePop(noEmpt);
    }
    
    int top = QueueFindFront(noEmpt);
    QueuePop(noEmpt);
    return top;
}

int myStackTop(MyStack* obj) {
    if (!QueueEmpt(&obj->q1))
    {
        return QueueFindBack(&obj->q1);
    }
    else
    {
        return QueueFindBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    //两个队列为空才为空
    return QueueEmpt(&obj->q1) && QueueEmpt(&obj->q2);
}

void myStackFree(MyStack* obj) {
    //显示放队列
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    //在释放结构体
    free(obj);
}