如何用两个队列实现栈的先进后出？

一、分析问题及代码实现分析
如果已经看过如何用两个栈实现队列的朋友，即使不知道这个问题的代码如何实现，那么也应该有大致的思路了，同样，我们需要一个新的结构体，里面有两个队列，还有一个对栈中元素计数的计数器变量

我们需要两个空队列，先将元素放入队列，然后再将非空队列的元素依次Pop放入空队列，直到非空队列的元素个数为1，（也就是如果非空队列中元素个数>1就一直Pop）此时再次进行Pop出的元素是我们所要的，然后又有一个空队列，和非空队列，如果在想取出元素就重复上述过程，但如果我们刚得到几个元素，又来了几个新的元素想要入队怎么办，我们要始终保证有一个队列是空的，所以新来的元素始终要入非空队列，然后让非空队列进行Pop，空队列Push,当然，第一次入队的时候就随机选择一个就可以了。
二、图示

三、代码实现

```c


#include<stdio.h>
#include<stdlib.h>

typedef struct data
{
    
    
	int nVaule;
	struct data *pNext;
}Myqueue;

typedef struct queue
{
    
    
	Myqueue *pTop;
	Myqueue *pTail;
	int nCount;
}Queue;

void q_Init(Queue **pQueue)
{
    
    
	*pQueue = (Queue*)malloc(sizeof(Queue));
	(*pQueue)->pTop = NULL;
	(*pQueue)->pTail = NULL;
	(*pQueue)->nCount = 0;
}

void q_Push(Queue *pQueue ,int nNum)
{
    
    
	if(pQueue == NULL) exit(1);

	Myqueue *pTemp = NULL;
	pTemp = (Myqueue*)malloc(sizeof(Myqueue));
	pTemp->nVaule = nNum;
	pTemp->pNext =NULL;
	if(pQueue->pTop == NULL)
	{
    
    
		pQueue->pTop = pTemp;
	}
	else
	{
    
    
		pQueue->pTail->pNext = pTemp;
	}
	pQueue->pTail = pTemp;
	pQueue->nCount ++;
}

int q_Pop(Queue *pQueue)
{
    
    
	if(pQueue == NULL) exit(1);
	if(pQueue->nCount == 0) return -1;

	Myqueue *pDel = pQueue->pTop;
	int nNum = pDel->nVaule;

	pQueue->pTop = pQueue->pTop->pNext;
	free(pDel);
	pDel = NULL;
	pQueue->nCount --;

	if(pQueue->nCount == 0)
	{
    
    
		pQueue->pTail = NULL;
	}
	return nNum;
}

int q_IsEmpty(Queue *pQueue)
{
    
    
	if(pQueue == NULL) exit(1);

	return pQueue->nCount == 0? 1:0;
}
typedef struct stack
{
    
    
	Queue *pQueue1;
	Queue *pQueue2;
	int nCount;
}Stack;

//以下为新代码
void s_Init(Stack **pStack)
{
    
    
	*pStack = (Stack*)malloc(sizeof(Stack));
	(*pStack)->nCount = 0;
	q_Init(&(*pStack)->pQueue1);
	q_Init(&(*pStack)->pQueue2);
}

void s_Push(Stack *pStack ,int nNum)
{
    
    
	if(pStack == NULL) exit(1);

	//将元素入非空队列
	if(!q_IsEmpty(pStack->pQueue1))
	{
    
    
		q_Push(pStack->pQueue1, nNum);
	}
	else
	{
    
    
		q_Push(pStack->pQueue2,nNum);
	}
	pStack->nCount++;
}


int s_Pop(Stack *pStack)
{
    
    
	if(pStack == NULL) exit(1);
	if(pStack->nCount == 0) return -1;
	int nNum=0;

	if(!q_IsEmpty(pStack->pQueue1))
	{
    
    
		while(pStack->pQueue1->nCount>1)
		{
    
    
			q_Push(pStack->pQueue2,q_Pop(pStack->pQueue1));
		}
		nNum = q_Pop(pStack->pQueue1);
	}
	else
	{
    
    
		while(pStack->pQueue2->nCount>1)
		{
    
    
			q_Push(pStack->pQueue1,q_Pop(pStack->pQueue2));
		}
		nNum =q_Pop(pStack->pQueue2);
	}
	pStack->nCount --;
	return nNum;
}

int main()
{
    
    
	Stack  *pSatck;
	s_Init(&pSatck);

	s_Push(pSatck,1);
	s_Push(pSatck,2);
	s_Push(pSatck,3);
	s_Push(pSatck,4);
	printf("%d\n",s_Pop(pSatck));
	printf("%d\n",s_Pop(pSatck));
	
	s_Push(pSatck,5);
	s_Push(pSatck,6);

	
	printf("%d\n",s_Pop(pSatck));
	printf("%d\n",s_Pop(pSatck));
	printf("%d\n",s_Pop(pSatck));
	printf("%d\n",s_Pop(pSatck));
	
	return 0;
}