栈和队列面试题

2.用两个栈实现队列

3.用两个队列实现栈

注意：对于代码中出现的头文件“Stack.h”与"Queue.h"可以参考上一篇博客

链接：https://blog.csdn.net/qq_40399012/article/details/81665085

代码：

头文件：topic.h

#ifndef __TOPIC_H__
#define __TOPIC_H__

#include "Queue.h"
#include "Stack.h"

/////////////////////////////////////////////////////////////
//2.用两个栈实现队列
typedef struct QueueByTwoStack
{
    Stack stack1;
    Stack stack2;
}QueueByTwoStack;

void QueueByTwoStackInit(QueueByTwoStack* qts);
void QueueByTwoStackDestory(QueueByTwoStack* qts);

void QueueByTwoStackPush(QueueByTwoStack* qts, DataType x);
void QueueByTwoStackPop(QueueByTwoStack* qts);
DataType QueueByTwoStackFront(QueueByTwoStack* qts);
int QueueByTwoStackEmpty(QueueByTwoStack* qts);
int QueueByTwoStackSize(QueueByTwoStack* qts);

////////////////////////////////////////////////////////////
//3.用两个队列实现栈
typedef struct StackByTwoQueue
{
    Queue queue1;
    Queue queue2;
}StackByTwoQueue;

void StackByTwoQueueInit(StackByTwoQueue* stq);
void StackByTwoQueueDestory(StackByTwoQueue* stq);

void StackByTwoQueuePush(StackByTwoQueue* stq, DataType x);
void StackByTwoQueuePop(StackByTwoQueue* stq);
DataType StackByTwoQueueTop(StackByTwoQueue* stq);
int StackByTwoQueueEmpty(StackByTwoQueue* stq);
int StackByTwoQueueSize(StackByTwoQueue* stq);

#endif //__TOPIC_H__

接口实现：topic.c

#include "Queue.h"
#include "Stack.h"
#include "topic.h"


////////////////////////////////////////////////////////////////////
//2.用两个栈实现一个队列
void QueueByTwoStackInit(QueueByTwoStack* qts)
{
    assert(qts);

    StackInit(&qts->stack1);
    StackInit(&qts->stack2);
}

void QueueByTwoStackDestory(QueueByTwoStack* qts)
{
    assert(qts);

    StackDestory(&qts->stack1);
    StackDestory(&qts->stack2);
}

void QueueByTwoStackPush(QueueByTwoStack* qts, DataType x)
{
    assert(qts);

    StackPush(&qts->stack1, x);
}

void QueueByTwoStackPop(QueueByTwoStack* qts)
{
    assert(qts);

    if (StackEmpty(&qts->stack2) != 0)
    {
        StackPop(&qts->stack2);
    }
    else
    {
        while (StackEmpty(&qts->stack1))
        {
            StackPush(&qts->stack2, StackTop(&qts->stack1));
            StackPop(&qts->stack1);
        }
        StackPop(&qts->stack2);
    }
}

DataType QueueByTwoStackFront(QueueByTwoStack* qts)
{
    assert(qts);

    if (StackEmpty(&qts->stack2) != 0)
    {
        return StackTop(&qts->stack2);
    }
    else
    {
        while (StackEmpty(&qts->stack1))
        {
            StackPush(&qts->stack2, StackTop(&qts->stack1));
            StackPop(&qts->stack1);
        }
        return StackTop(&qts->stack2);
    }
}

int QueueByTwoStackEmpty(QueueByTwoStack* qts)
{
    assert(qts);

    return StackEmpty(&qts->stack1) | StackEmpty(&qts->stack2);
}

int QueueByTwoStackSize(QueueByTwoStack* qts)
{
    assert(qts);

    return StackSize(&qts->stack1) + StackSize(&qts->stack2);
}



/////////////////////////////////////////////////////////////////////////
//3.用两个队列实现一个栈
void StackByTwoQueueInit(StackByTwoQueue* stq)
{
    assert(stq);

    QueueInit(&stq->queue1);
    QueueInit(&stq->queue2);
}

void StackByTwoQueueDestory(StackByTwoQueue* stq)
{
    assert(stq);

    QueueDestory(&stq->queue1);
    QueueDestory(&stq->queue2);
}

void StackByTwoQueuePush(StackByTwoQueue* stq, DataType x)
{
    assert(stq);

    if (QueueEmpty(&stq->queue1))
    {
        QueuePush(&stq->queue1, x);
    }
    else
    {
        QueuePush(&stq->queue2, x);
    }
}
void StackByTwoQueuePop(StackByTwoQueue* stq)
{
    assert(stq);

    Queue* empty = &stq->queue1;
    Queue* nonempty = &stq->queue2;
    if (QueueEmpty(&stq->queue1))
    {
        empty = &stq->queue2;
        nonempty = &stq->queue1;
    }
    while (QueueSize(nonempty) > 1)
    {
        QueuePush(empty, QueueFront(nonempty));
        QueuePop(nonempty);
    }
    QueuePop(nonempty);
}

DataType StackByTwoQueueTop(StackByTwoQueue* stq)
{
    assert(stq);

    if (QueueEmpty(&stq->queue1))
    {
        return QueueBack(&stq->queue1);
    }
    else
    {
        return QueueBack(&stq->queue2);
    }
}

int StackByTwoQueueEmpty(StackByTwoQueue* stq)
{
    assert(stq);

    return QueueEmpty(&stq->queue1) | QueueEmpty(&stq->queue2);
}

int StackByTwoQueueSize(StackByTwoQueue* stq)
{
    assert(stq);

    return QueueSize(&stq->queue1) + QueueSize(&stq->queue2);
}

测试部分：test.c

#include "Stack.h"
#include "Queue.h"
#include "topic.h"

void TestQueueByTwoStack()
{
    QueueByTwoStack queue;

    QueueByTwoStackInit(&queue);
    QueueByTwoStackPush(&queue, 1);
    QueueByTwoStackPush(&queue, 2);
    QueueByTwoStackPush(&queue, 3);
    QueueByTwoStackPush(&queue, 4);

    while (QueueByTwoStackEmpty(&queue))
    {
        printf("%d ", QueueByTwoStackFront(&queue));
        QueueByTwoStackPop(&queue);
    }
    printf("\n");
    QueueByTwoStackDestory(&queue);
}
    

void TestStackByTwoQueue()
{
    StackByTwoQueue stack;
    StackByTwoQueueInit(&stack);
    StackByTwoQueuePush(&stack, 1);
    StackByTwoQueuePush(&stack, 2);
    StackByTwoQueuePush(&stack, 3);
    StackByTwoQueuePush(&stack, 4);

    while (StackByTwoQueueEmpty(&stack))
    {
        printf("%d ", StackByTwoQueueTop(&stack));
        StackByTwoQueuePop(&stack);
    }
    printf("\n");
    StackByTwoQueueDestory(&stack);
}

int main()
{
    TestQueueByTwoStack();
    TestStackByTwoQueue();
    return 0;
}

数据结构| |栈和队列面试题

栈和队列面试题

2.用两个栈实现队列

3.用两个队列实现栈

猜你喜欢