用队列实现栈（利用两个队列）

• 使用队列实现栈的下列操作：

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
{
	struct QueueNode* _prev;
	struct QueueNode* _tail;
}Queue;
//队列里面的头和尾也是一个结点
void QueueInit(Queue* pq){
  pq->_prev = NULL;
 }
 
void QueueDestory(Queue* pq){
//队列中的每一个结点都要销毁。
  QueueNode* cur = pq->_prev;
  while (cur!=NULL){
    QueueNode* tail = cur->_next;
    pq->_prev = pq->_prev->_next;
    cur = tail;
   }
  pq->_prev = NULL;
 }
   
QueueNode* BuyQueueNode(QUDataType x){
  QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  newnode->_data = x;
  newnode->_next = NULL;
  return newnode;
 }
  
void QueuePush(Queue* pq, QUDataType x){
   QueueNode* cur = BuyQueueNode(x);
   if (pq->_prev==NULL){
     pq->_prev = pq->_tail = cur;
    }
   pq->_tail->_next = cur;//把新的结点插到列表的尾部
   pq->_tail = pq->_tail->_next;//列表的尾指针向后走一步
  }
  
void QueuePop(Queue* pq){
  if (pq->_prev==NULL){
    return;
   }
  if (pq->_prev==pq->_tail){
    pq->_tail = NULL;
    //当头尾指针在同一个地方时，说明只有一个结点，删除后，尾指针变空
   } 
   QueueNode* cur = pq->_prev;
   pq->_prev = pq->_prev->_next;
   free(cur);//删除结点的意思就是把首节点释放掉。
  }
 
QUDataType QueueFront(Queue* pq){
  if (QueueEmpty(&pq)==0){
     return NULL;
   }
  return pq->_prev->_data;
 }
 
QUDataType QueueBack(Queue* pq){
   return pq->_tail->_data;
 }
 
int QueueEmpty(Queue* pq){
   if (pq->_prev!=NULL){
     return 1;
    }
   return 0;
 }
 
int QueueSize(Queue* pq){
  QueueNode* cur = pq->_prev;
  int size = 0;
  while (cur){
   size++;
   cur = cur->_next;
  }
  return size;
 }
 
 
typedef struct {
    Queue pq1;
    Queue pq2;
} MyStack;

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

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

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    Queue* empty = &obj->pq1;
    Queue* nonempty = &obj->pq2;
    if (QueueEmpty(&obj-<pq1)!=0){
      empty = &obj->pq2;
      nonempty = &obj->pq1;
    }
    while (QueueSize(nonempty)>1){
      QueuePuah(empty,QueueFront(nonempty));
      QueuePop(nonempty);
    }
    int tmp = QueueFront(nonempty);
    QueuePop(nonempty);
    return tmp;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    Queue* empty = &obj->pq1;
    Queue* nonempty = &obj->pq2;
    if (QueueEmpty(&obj-<pq1)!=0){
      empty = &obj->pq2;
      nonempty = &obj->pq1;
    }
    while (QueueSize(nonempty)>1){
      QueuePuah(empty,QueueFront(nonempty));
      QueuePop(nonempty);
    }
    int tmp = QueueFront(nonempty);
    QueuePuah(empty,tmp));
    QueuePop(nonempty);
    return tmp;    
}

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

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