用队列实现栈

使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
注意:
你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

typedef int QUDataType;
typedef struct QueueNode
{
	QUDataType _data;
	struct QueueNode* _next;
}QueueNode;
typedef struct Queue
{
	QueueNode* _head;
	QueueNode* _tail;
}Queue;
void QueueInit(Queue* q)
{
	assert(q);
	q->_head = q->_tail = NULL;
}

void QueueDestroy(Queue* q)
{
	assert(q);
	QueueNode* cur = q->_head;
	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_head = q->_tail = NULL;
}


void QueuePush(Queue* q, QUDataType x)
{
	assert(q);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->_data = x;
	newnode->_next = NULL;
	if (q->_tail == NULL)
	{
		q->_head = q->_tail = newnode;
	}
	else
	{
		q->_tail->_next = newnode;
		q->_tail = q->_tail->_next;
	}
}
void QueuePop(Queue* q)
{
	assert(q);
		QueueNode* newhead = q->_head->_next;
		free(q->_head);
		q->_head = newhead;
		if (newhead == NULL)
		{
			q->_tail = NULL;
		}
}
int QueueSize(Queue* q)
{
	assert(q);
	int size = 0;
	QueueNode* cur = q->_head;
	while (cur != NULL)
	{
		++size;
		cur = cur->_next;
	}
	return size;
}

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_head == NULL ? 0 : 1;
}

QUDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_head->_data;
}
QUDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_tail->_data;
}
typedef struct {
    Queue q1;
    Queue q2;
    
} MyStack;

/** Initialize your data structure here. */
MyStack* myStackCreate(int maxSize) {
    MyStack* st = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    if(QueueEmpty(&obj->q1) != 0)
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
                 
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
       Queue* Empty = &obj->q1;
       Queue* NonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        Empty = &obj->q2;
        NonEmpty = &obj->q1;
    }
    while(QueueSize(NonEmpty) > 1)
    {
        QueuePush(Empty,QueueFront(NonEmpty));
        QueuePop(NonEmpty);
    }
    int top = QueueFront(NonEmpty);
    QueuePop(NonEmpty);
    return top;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
     Queue* Empty = &obj->q1;
       Queue* NonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        Empty = &obj->q2;
        NonEmpty = &obj->q1;
    }
    return QueueBack(NonEmpty);
    
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) == 0 && QueueEmpty(&obj->q2) == 0;
}

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