用队列实现栈

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

队列：先进先出
栈：后进先出

利用两个队列的不断导值实现出一个栈的功能


代码：

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

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

void QueueInit(Queue* pq);//初始化
void QueuePush(Queue* pq, QDataType x);//插入数据
bool QueueEmpty(Queue* pq);//判空
void QueueBack(Queue* pq);//头删
QDataType QueueFront(Queue* pq);//返回头值
QDataType QueueBront(Queue* pq);//返回尾值
int QueueSize(Queue* pq);//返回长
void QueueDestroy(Queue* pq);//释放


void QueueInit(Queue* pq)//初始化
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}


void QueuePush(Queue* pq, QDataType x)//插入数据
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("mallos fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->tail = pq->head = newnode;
		pq->size++;
	}
	else
	{
		pq->tail->next = newnode;//尾插
		pq->tail = newnode;//移动
		pq->size++;
	}
}

void QPrint(Queue* pq)//打印
{
	QNode* cur = pq->head;
	while (cur)
	{
		printf("%d", cur->data);
		cur = cur->next;
	}
}


void QueueBack(Queue* pq)//头删
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		pq->tail = NULL;
	}
	QNode* per = pq->head->next;
	free(pq->head);
	pq->head = per;
	
	pq->size--;
}

QDataType QueueFront(Queue* pq)//返回头值
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}


QDataType QueueBront(Queue* pq)//返回尾值
{
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)//判空
{
	assert(pq);
	return pq->head == NULL;
}

int QueueSize(Queue* pq)//返回长
{
	assert(pq);
	return pq->size;
}
void QueueDestroy(Queue* pq)//释放
{
	assert(pq);
	QNode* cur = pq->head;
	while(cur)
	{
		QNode* per = cur->next;
		free(cur);
		cur = per;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}



typedef struct {
    Queue q1;
    Queue q2;

} MyStack;//这就相当于模拟出来的栈的结构


MyStack* myStackCreate() {//用结构体指针开辟出一个“模拟栈”的空间
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);//先初始化两个队列
    QueueInit(&obj->q2);

    return obj;
}

void myStackPush(MyStack* obj, int x) {//在不为空的那个队列里放入数据，就相当于“模拟栈”压栈
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }else
    {
        QueuePush(&obj->q2, x);
    }

}

int myStackPop(MyStack* obj) {
    Queue*empty=&obj->q1;
    Queue*noempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        noempty=&obj->q1;
    }
    while(QueueSize(noempty)>1)//将不为空的那个队列的前面szie-1个数
    {
        QueuePush(empty, QueueFront(noempty));//压到为空的那个队列里，
        QueueBack(noempty);//压一个，就在不为空队列里删一个
    }
		//当循环结束后，就只剩下一个元素，把他出队，就相当于出栈
    int top=QueueFront(noempty);
    QueueBack(noempty);
    return top;

}

int myStackTop(MyStack* obj) {//栈顶元素，就相当于是不为空的那个队列的尾元素
    if(!QueueEmpty(&obj->q1))
    {
    return  QueueBront(&obj->q1);
    }
		else
    {
    return  QueueBront(&obj->q2);
    }

}

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

void myStackFree(MyStack* obj) {//释放
//先释放连个队列
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
//再释放模拟栈
    free(obj);

}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/