1. 使用两个栈实现一个队列

分析：队列是先进先出的，而栈是先进后出的，所以需要用两个栈去实现一个队列；一个栈专门进行入队列操作，另一个栈负责出队列操作。

头文件：

StackAndQueueInterview.h：

// 用两个栈来封装成一个队列
typedef struct QueueByStack
{
    Stack s1;//负责入队列
    Stack s2;//负责出队列
}QueueByStack;

void QueueByStackInit(QueueByStack* q);//初始化
void QueueByStackPush(QueueByStack* q, DataType data);//入队列
int QueueByStackEmpty(QueueByStack* q);//判空
void QueueByStackPop(QueueByStack* q);//出队列
int QueueByStackSize(QueueByStack* q);//获取队列中元素的个数
DataType QueueByStackFront(QueueByStack* q);//获取队头元素(取s2的栈顶元素)
DataType QueueByStackBack(QueueByStack* q);//获取队尾元素(取栈s1的栈顶元素)
void TestQueueByStack();

源文件：

初始化

void QueueByStackInit(QueueByStack* q)
{
    StackInit(&q->s1);
    StackInit(&q->s2);
}

入队列

void QueueByStackPush(QueueByStack* q, DataType data)
{
    StackPush(&q->s1, data);
}

判空

int QueueByStackEmpty(QueueByStack* q)
{
    return StackEmpty(&q->s1) && StackEmpty(&q->s2);
}

出队列

void QueueByStackPop(QueueByStack* q)
{
    // 如果s1和s2都为空，则是空队列
    if (QueueByStackEmpty(&q))
        return;
    // 如果栈s2为空，就将s1中的元素导入到s2中去
    if (StackEmpty(&q->s2))
    {
        while (!StackEmpty(&q->s1))
        {
            StackPush(&q->s2, StackTop(&q->s1));
            StackPop(&q->s1);
        }
    }
    // 从s2中出元素
    StackPop(&q->s2);
}

获取队列中元素的个数

int QueueByStackSize(QueueByStack* q)
{
    return StackSize(&q->s1) + StackSize(&q->s2);
}

获取队头元素(取s2的栈顶元素)

DataType QueueByStackFront(QueueByStack* q)
{
    assert(QueueByStackEmpty(&q));//队列为空

    if (StackEmpty(&q->s2))//栈s2为空，将栈s1的元素导入到s2中去
    {
        while (!StackEmpty(&q->s1))
        {
            StackPush(&q->s2, StackTop(&q->s1));
        }
    }
    //取s2的栈顶元素
    return StackTop(&q->s2);    
}

获取队尾元素(取栈s1的栈顶元素)

DataType QueueByStackBack(QueueByStack* q)
{
    assert(QueueByStackEmpty(&q));

    if (StackEmpty(&q->s1))//如果栈s1为空，就将s2中的元素导入到s1中去
    {
        while (!StackEmpty(&q->s2))
        {
            StackPush(&q->s1, StackTop(&q->s2));
        }
    }
    //取s1的栈顶元素
    return StackTop(&q->s1);
}

测试

void TestQueueByStack()
{
    QueueByStack q;
    QueueByStackInit(&q);

    QueueByStackPush(&q, 1);
    QueueByStackPush(&q, 2);
    QueueByStackPush(&q, 3);
    QueueByStackPush(&q, 4);
    QueueByStackPush(&q, 5);
    printf("size=%d\n", QueueByStackSize(&q));
    printf("front=%d\n", QueueByStackFront(&q));
    printf("back=%d\n", QueueByStackBack(&q));

    QueueByStackPop(&q);
    printf("size=%d\n", QueueByStackSize(&q));
    printf("front=%d\n", QueueByStackFront(&q));
    printf("back=%d\n", QueueByStackBack(&q));
}

2. 使用两个队列实现一个栈

分析：队列是先进先出，而栈是先进后出

头文件：

//用两个队列来封装成一个栈
typedef struct StackBy2Queue
{
    Queue q1;
    Queue q2;
}StackBy2Queue;

void StackBy2QueueInit(StackBy2Queue* s);//初始化栈
void StackBy2QueuePush(StackBy2Queue* s, DataType data);//入栈
int StackBy2QueueEmpty(StackBy2Queue* s);//判空
void StackBy2QueuePop(StackBy2Queue* s);//出栈
DataType StackBy2QueueTop(StackBy2Queue* s);//获取栈顶元素
int StackBy2QueueSize(StackBy2Queue* s);//获取栈中元素的个数
void TestStackBy2Queue();

源文件：

初始化栈

void StackBy2QueueInit(StackBy2Queue* s)
{
    QueueInit(&s->q1);
    QueueInit(&s->q2);
}

入栈

void StackBy2QueuePush(StackBy2Queue* s,DataType data)
{
    if (!QueueEmpty(&s->q1))
        QueuePush(&s->q1,data);
    else
        QueuePush(&s->q2, data);
}

判空

int StackBy2QueueEmpty(StackBy2Queue* s)
{
    return QueueEmpty(&s->q1) && QueueEmpty(&s->q2);
}

出栈

void StackBy2QueuePop(StackBy2Queue* s)
{
    if (StackBy2QueueEmpty(&s))
        return;
    // 如果q1为空，将队列q2中的元素搬到队列q1中去，直到q2中只剩下一个元素，此时将该元素出队列即可）
    if (QueueEmpty(&s->q1))
    {
        // 搬元素
        while (QueueSize(&s->q2) > 1)
        {
            QueuePush(&s->q1, QueueFront(&s->q2));
            QueuePop(&s->q2);
        }
        QueuePop(&s->q2);
    }
    else
    {
        // 搬元素
        while (QueueSize(&s->q1) > 1)
        {
            QueuePush(&s->q2, QueueFront(&s->q1));
            QueuePop(&s->q1);
        }
        QueuePop(&s->q1);
    }
}

获取栈顶元素

DataType StackBy2QueueTop(StackBy2Queue* s)
{
    if (!QueueEmpty(&s->q1))
        return QueueBack(&s->q1);
    else
        return QueueBack(&s->q2);
}

获取栈中元素的个数

int StackBy2QueueSize(StackBy2Queue* s)
{
    return QueueSize(&s->q1) + QueueSize(&s->q2);
}

测试

void TestStackBy2Queue()
{
    StackBy2Queue s;
    StackBy2QueueInit(&s);

    StackBy2QueuePush(&s, 1);
    StackBy2QueuePush(&s, 2);
    StackBy2QueuePush(&s, 3);
    StackBy2QueuePush(&s, 4);
    printf("size=%d\n", StackBy2QueueSize(&s));
    printf("top=%d\n", StackBy2QueueTop(&s));

    StackBy2QueuePop(&s);
    printf("size=%d\n", StackBy2QueueSize(&s));
    printf("top=%d\n", StackBy2QueueTop(&s));

    StackBy2QueuePop(&s);
    printf("size=%d\n", StackBy2QueueSize(&s));
    printf("top=%d\n", StackBy2QueueTop(&s));

    StackBy2QueuePush(&s, 5);
    printf("size=%d\n", StackBy2QueueSize(&s));
    printf("top=%d\n", StackBy2QueueTop(&s));
}