力扣https://leetcode-cn.com/problems/implement-stack-using-queues/点击上面网址可查看原题

题目

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

解答

首先我们先把队列的接口函数完善进去

//实现队列
typedef int QDataType;
typedef struct QueueNode{
    struct QueueNode* next;
    QDataType data;
}QueueNode;

typedef struct Queue{
    QueueNode* front;
    QueueNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq){
    assert(pq);
    pq->front=pq->tail=NULL;
}
//插入元素
void QueuePush(Queue* pq,QDataType x){
    assert(pq);
    QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
    newnode->data=x;
    newnode->next=NULL;
    if(pq->front==NULL){
        pq->front=pq->tail=newnode;
    }else{
        pq->tail->next=newnode;
        pq->tail=pq->tail->next;
    }
}
//删除元素
void QueuePop(Queue* pq){
    assert(pq);
    assert(pq->front);
    if(pq->front==pq->tail){
        free(pq->front);
        pq->front=pq->tail=NULL;
    }else{
        QueueNode* cur=pq->front;
        pq->front=pq->front->next;
        free(cur);
    }
}
//读取队首元素
QDataType QueueFront(Queue* pq){
    assert(pq);
    assert(pq->front);
    return pq->front->data;
}
//读取队尾元素
QDataType QueueBack(Queue* pq){
    assert(pq);
    assert(pq->tail);
    return pq->tail->data;
}
//判断队空
bool QueueEmpty(Queue* pq){
    assert(pq);
    return pq->front==NULL;
}
//销毁队列
void QueueDestroy(Queue* pq){
    assert(pq);
    while(!QueueEmpty(pq)){
        QueuePop(pq);
    }
    pq->front=pq->tail=NULL;
}
//队列元素个数
int QueueSize(Queue* pq) {//有些地方会在结构体里给size，直接访问就可以但一般面试不给
    assert(pq);
    int n = 0;
    QueueNode* cur = pq->front;
    while (cur) {
        ++n;
        cur = cur->next;
    }
    return n;
}

然后在完善MyStack的功能

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


MyStack* myStackCreate() {
    MyStack* st=(MyStack*)malloc(sizeof(MyStack));//出了函数还在，因为是malloc出来的
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;
}

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1,x);
    }else{
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* emptyQ=&obj->q1;
    Queue* nonemptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1)){
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
    }

    while(QueueSize(nonemptyQ)>1){
        QueuePush(emptyQ,QueueFront(nonemptyQ));
        QueuePop(nonemptyQ);
    }
    int top=QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);
    return top;
}


int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1)){
        return QueueBack(&obj->q1);
    }else{
        return QueueBack(&obj->q2);
    }

}


bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}


void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

标签：assert,pq,obj,OJ,4.2,队列,Queue,front,MyStack
来源： https://blog.csdn.net/m0_62516234/article/details/121294645