两个队列实现一个栈

全部代码

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

typedef struct node
{
    int nValue;
    struct node *pNext;
}MyQueue;

typedef struct node2
{
    int nCount;
    MyQueue *pHead;
    MyQueue *pTail;
}Queue;

void q_Init(Queue **ppQueue)
{
    assert(ppQueue!=NULL);

    *ppQueue = (Queue *)malloc(sizeof(Queue));
    if(NULL == *ppQueue)
    {
        printf("*ppQueue分配空间失败！
");
        exit(-1);
    }
    (*ppQueue)->nCount = 0;
    (*ppQueue)->pHead = NULL;
    (*ppQueue)->pTail = NULL;
}

//尾添加
void q_Push(Queue *pQueue, int nNum)
{
    MyQueue *pTemp = NULL;

    //队列存在
    assert(pQueue!=NULL);

    pTemp = (MyQueue *)malloc(sizeof(MyQueue));
    if(NULL == pTemp)
    {
        printf("pTemp空间分配失败！
");
        exit(-1);
    }
    pTemp->nValue = nNum;
    pTemp->pNext = NULL;

    //队列空
    if(NULL == pQueue->pHead)
    {
        pQueue->pHead = pTemp;
    }
    else
    {
        pQueue->pTail->pNext = pTemp;
    }
    pQueue->pTail = pTemp;

    //更新队列元素
    ++pQueue->nCount;
}

//头删除
int q_Pop(Queue *pQueue)
{
    int nNum;
    MyQueue *pDel = NULL;

    //队列存在且队列非空
    assert(pQueue!=NULL && pQueue->pHead!=NULL);

    pDel = pQueue->pHead;
    nNum = pDel->nValue;
    pQueue->pHead = pQueue->pHead->pNext;
    free(pDel);
    pDel = NULL;

    //更新队列元素
    --pQueue->nCount;

    //队列在元素删除后为空 尾置空
    if(0 == pQueue->nCount)
    {
        pQueue->pTail = NULL;
    }

    return nNum;
}

int q_IsEmpty(Queue *pQueue)
{
    //队列存在
    assert(pQueue!=NULL);

    return 0==pQueue->nCount?1 : 0;
}

typedef struct node3
{
    int nCount;
    Queue *pQueue1;
    Queue *pQueue2;
}Stack;

void s_Init(Stack **ppStack)
{
    assert(ppStack!=NULL);

    *ppStack = (Stack *)malloc(sizeof(Stack));
    if(NULL == *ppStack)
    {
        printf("*ppStack空间分配失败！
");
        exit(-1);
    }
    (*ppStack)->nCount = 0;
    (*ppStack)->pQueue1 = NULL;
    (*ppStack)->pQueue2 = NULL;

    //申请两个队列
    q_Init(&(*ppStack)->pQueue1);
    q_Init(&(*ppStack)->pQueue2);
}

void s_Push(Stack *pStack, int nNum)
{
    //栈存在
    assert(pStack!=NULL && pStack->pQueue1!=NULL && pStack->pQueue2!=NULL);

    if(!q_IsEmpty(pStack->pQueue1))
    {
        q_Push(pStack->pQueue1, nNum);
    }
    else
    {
        q_Push(pStack->pQueue2, nNum);
    }

    //更新栈内元素
    ++pStack->nCount;
}

int s_Pop(Stack *pStack)
{
    int nNum;

    //栈存在且栈非空
    assert(pStack!=NULL && pStack->nCount!=0 && pStack->pQueue1!=NULL && pStack->pQueue2!=NULL);

    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(void)
{
    Stack *pStack = NULL;

    s_Init(&pStack);
    //添加
    s_Push(pStack, 1);
    s_Push(pStack, 2);
    s_Push(pStack, 3);
    s_Push(pStack, 4);
    //弹出
    printf("%d ", s_Pop(pStack));
    printf("%d ", s_Pop(pStack));
    printf("%d ", s_Pop(pStack));
    printf("%d ", s_Pop(pStack));

    return 0;
}