用队列实现栈--用两个队列模拟实现栈

出栈：哪个队列不为空，将该队列中前n-1个元素挪到另一个空队列中，然后将该队列中仅剩的元素出队列。

入栈：哪个队列不为空，将元素放到哪个队列中即可。

获取栈顶元素：哪个队列不为空，该队列的队尾就是栈顶元素。 

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


typedef struct Queue
{
	QNode* front;   // 队头
	QNode* back;    // 队尾
}Queue;

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


QNode* buyQNode(QDataType data)
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (NULL == newNode)
	{
		assert(0);
		return NULL;
	}

	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}

// 初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->front = buyQNode(0);
	q->back = q->front;
}

// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newNode = buyQNode(data);
	q->back->next = newNode;
	q->back = newNode;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == q->back;
}

// 队头出队列
void QueuePop(Queue* q)
{
	QNode* delNode = NULL;
	if (QueueEmpty(q))
		return;

	delNode = q->front->next;
	q->front->next = delNode->next;
	// 注意：队列中刚好只有一个元素，删除之后应该要将队尾back放在头节点的位置
	if (delNode == q->back)
		q->back = q->front;
	free(delNode);
}

// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->front->next->data;
}

// 获取队列尾部元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->back->data;
}

// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->front->next;
	int count = 0;
	while (cur)
	{
		count++;
		cur = cur->next;
	}

	return count;
}



// 销毁队列
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front->next;
	while (cur)
	{
		q->front->next = cur->next;
		free(cur);
		cur = q->front->next;
	}

	free(q->front);
	q->front = q->back = NULL;
}


//模拟栈初始化

MyStack* myStackCreate() {
    MyStack* mystack=(MyStack*)malloc(sizeof(MyStack));
    if(mystack==NULL)
    {
        return NULL;
    }
    QueueInit(&mystack->q1);
    QueueInit(&mystack->q2);
   
    return mystack;

}

//用队列模拟入栈
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
        QueuePush(&obj->q2,x);
    
}


///获取模拟栈的栈顶元素
int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
      return QueueBack(&obj->q1);   
    }
    else
    {
         return  QueueBack(&obj->q2);   
    }

}

//用队列模拟出栈
int myStackPop(MyStack* obj) {
    int ret;
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        while(QueueSize(&obj->q1)>1)
        {
            QueuePush(&obj->q2, QueueFront(&obj->q1));  
            QueuePop(&obj->q1);
        } 
         ret= QueueFront(&obj->q1);  
        QueuePop(&obj->q1);
    }
    else
    {
        while(QueueSize(&obj->q2)>1)
        {
            QueuePush(&obj->q1, QueueFront(&obj->q2)); 
            QueuePop(&obj->q2);
        } 
         ret=QueueFront(&obj->q2);  
         QueuePop(&obj->q2);
    }

    return ret;
   
}


//判断模拟栈是否为空
bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);

}


//模拟栈的销毁
void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);

}