目录

一、题目介绍

二、题目分析

三、代码实现

题目链接：225. 用队列实现栈 - 力扣（LeetCode）

一、题目介绍

 

二、题目分析

队列的特性是先进先出，栈的特性是后进先出，我们有前面用栈实现队列，我们可以利用类似的思路来实现，我们需要画图来解决问题

我们要将1,2,3,4,5入栈，但是我们的底层是用队列来实现的，按照我们前面的思路，我们将其中一个队列的元素一直导入到另一个队列中，直到剩下最后一个元素，我们会发现，导入到另一个队列之后，它的元素的顺序刚好倒了过来，可以直接出数据就是正确的顺序，并不需要再将元素倒回来

 

所以我们可以命名其中一个队列专门来实现push操作，另一个队列专门用来实现pop操作

剩下的思路就跟用栈实现队列一致了，如果pop队列为空，就将push队列的元素导入到pop队列中 

三、代码实现

typedef int QDataType;

typedef struct QNode
{
	struct QNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq);
// 队尾入队列 
void QueuePush(Queue* pq, QDataType x);
// 队头出队列 
void QueuePop(Queue* pq);
// 获取队列头部元素 
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数 
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq);
// 销毁队列 
void QueueDestroy(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);

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


void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		printf("malloc failn");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;

	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

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

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

int QueueSize(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		cur = cur->next;
		++size;
	}
	return size;
}


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


MyStack* myStackCreate() {
     MyStack*st=(MyStack*)malloc(sizeof(MyStack));
     QueueInit(&st->q1);
     QueueInit(&st->q2);
     return st;
}
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}
void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue*emptyQ=&obj->q1;
    Queue*nonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        nonEmpty=&obj->q1;
    }
    
    while(QueueSize(nonEmpty)>1)
    {
        QueuePush(emptyQ,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }

    int ret=QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return ret;

}

int myStackTop(MyStack* obj) {
    Queue*emptyQ=&obj->q1;
    Queue*nonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        nonEmpty=&obj->q1;
    }
    
    return  QueueBack(nonEmpty);
    
}



void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}