【力扣】用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode）

题目：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
 

注意：

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

思路：

队列的特点是先进先出，栈的特点是先进后出

本题需要用到两个队列

 

代码：

typedef int QueueDataType;
typedef struct QueueNode
{
	QueueDataType data;
	struct QueueNode* next;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;

}Queue;
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* temp = cur->next;
		free(cur);
		cur = temp;
	}
	pq->head = NULL;
	pq->tail = NULL;
}
//尾进头出
void QueuePush(Queue* pq, QueueDataType x)
{
	assert(pq);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newNode);
	newNode->data = x;
	newNode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
}
void QueuePop(Queue* pq)
{
	assert(pq);

	if (pq->head->next)
	{
		QueueNode* headNext = pq->head->next;
		free(pq->head);
		pq->head = headNext;
	}
	else
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
}
size_t QueueSize(Queue* pq)
{
	size_t size = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}
bool QueueEmpty(Queue* pq)
{
	return pq->head == NULL;
}
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->data;
}

typedef struct
{
	Queue Q1;
	Queue Q2;
} MyStack;


MyStack* myStackCreate()
{
	MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&stack->Q1);
	QueueInit(&stack->Q2);
	return stack;
}

void myStackPush(MyStack* obj, int x)
{
	Queue* qNotNull = obj->Q1.head != NULL ? &obj->Q1 : &obj->Q2;//不为空的队列
	QueuePush(qNotNull, x);
}

int myStackPop(MyStack* obj)
{
	Queue* qNotNull ;
	Queue* qNull;
	if (obj->Q1.head)
	{
		qNotNull = &obj->Q1;
		qNull = &obj->Q2;
	}
	else
	{
		qNotNull = &obj->Q2;
		qNull = &obj->Q1;
	}
	QueueDataType temp = 0;
	while (qNotNull->head != qNotNull->tail)
	{
		temp = qNotNull->head->data;
		QueuePop(qNotNull);
		QueuePush(qNull, temp);
	}
	temp = qNotNull->head->data;
	QueuePop(qNotNull);
	return temp;
}

int myStackTop(MyStack* obj)
{
	Queue qNotNull;
	Queue qNull;
	if (obj->Q1.head)
	{
		qNotNull = obj->Q1;
		qNull = obj->Q2;
	}
	else
	{
		qNotNull = obj->Q2;
		qNull = obj->Q1;
	}
	QueueDataType temp = 0;

	temp = qNotNull.tail->data;

	return temp;
}

bool myStackEmpty(MyStack* obj)
{
	if (obj->Q1.head == NULL && obj->Q2.head == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void myStackFree(MyStack* obj)
{
	QueueDestroy(&obj->Q1);
	QueueDestroy(&obj->Q2);
}