力扣 225. 用队列实现栈

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/implement-stack-using-queues

使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空

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

---

一、实现队列

先实现队列的基本操作，之后再实现栈。

typedef int QDataType;

typedef struct QNode{
	struct QNode* _next;
	QDataType _data;
}QNode;

typedef struct Queue{
	QNode* _front;
	QNode* _rear;
}Queue;

void queueInit(Queue* q){
	q->_front = q->_rear = NULL;
}

QNode* createNode(QDataType data){
	QNode* node = (QNode*)malloc(sizeof(QNode));
	node->_data = data;
	node->_next = NULL;
	return node;
}

void queuePush(Queue* q, QDataType data){
	if (q == NULL){	//注意判空
		return;
	}
	QNode* node = createNode(data);
	if (q->_front == NULL){	//若入队的是第一个元素，需要特殊处理
		q->_front = q->_rear = node;
	}
	else{
		q->_rear->_next = node;
		q->_rear = node;
	}

}

void queuePop(Queue* q){
	if (q->_front){		//同样需要判断队列中是否还剩余元素
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
		if (q->_front == NULL){		//出队最后一个元素后，队尾指针需要设为NULL
			q->_rear = NULL;		//否则会产生野指针
		}
	}
}

QDataType queueFront(Queue* q){
	return q->_front->_data;
}

QDataType queueBack(Queue* q){
	return q->_rear->_data;
}

QDataType queueSize(Queue* q){
	if (q == NULL){
		return 0;
	}
	int num = 0;
	QNode* cur = q->_front;
	while (cur){
		num++;
		cur = cur->_next;
	}
	return num;
}

int queueEmpty(Queue* q){
	if (q->_front == NULL){
		return 1;
	}
	else{
		return 0;
	}
}

void queueDestroy(Queue* q){
	QNode* cur = q->_front;
	while (cur){
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_rear = NULL;

}

二、用队列实现栈

队列实现栈的基本思路是：将要出栈元素以外的所有元素挪到此元素之后，再执行出队。例如，队列中有1、2、3、4、5五个元素，现在进行出栈操作，那么就是要让元素5出栈。此时，我们将1、2、3、4挪到5后面，使得5成为队头元素，再使用出队函数即可。即变化为5、1、2、3、4后进行出队，这样就模拟了出栈（后进先出）的操作。

typedef struct {
	Queue q;
} MyStack;

/** Initialize your data structure here. */

MyStack* myStackCreate() {
	MyStack* ms = (MyStack*)malloc(sizeof(MyStack));
	queueInit(&ms->q);
	return ms;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
	queuePush(&obj->q, x);
}

定义MyStack结构体。MyStack实质上就是队列，也就是说，用一个队列就可以实现一个栈。栈的初始化和入栈操作实际上就是队列的初始化和入队操作。

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
	int size = queueSize(&obj->q);
	while (size > 1){
		int front = queueFront(&obj->q);
		queuePop(&obj->q);
		queuePush(&obj->q, front);
		size--;
	}
	int ret = queueFront(&obj->q);
	queuePop(&obj->q);
	return ret;
}

重点来了，根据刚才所叙述的思路编写代码，实现出栈操作。首先需要一个size变量储存队列中元素的个数，将队头元素放入front变量中，然后出队。再将front变量入队，相当于完成了一个元素从队头到队尾的搬移。使用循环结构重复这一操作，直到需要出栈的元素来到队头。最后出队（相当于出栈）。然后根据题目要求，返回出栈元素的值。

/** Get the top element. */
int myStackTop(MyStack* obj) {
	return queueBack(&obj->q);
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
	if (queueEmpty(&obj->q) == 1){
		return true;
	}
	return false;
}

void myStackFree(MyStack* obj) {
	queueDestroy(&obj->q);
	free(obj);
}

这三个函数难度不大。取出栈顶元素等价于取出队尾元素，判断栈空等价于判断队列空，销毁栈等价于销毁队列。因此直接调用之前编写好的队列相关操作即可。