用队列模拟实现栈

实现思路

使用两个队列，要执行数据插入操作时，选择不为空的队列插入，如果都为空就随机插入一个队列。要执行数据删除操作时，将有数据的队列元素除了最后一个全部移到空队列，然后将这一个元素删除即可。

下次要pop时，只要将队列2执行此操作即可

代码实现

c语言实现队列模拟栈需要提前写有关队列的代码，此文可参考

//队列代码
typedef int QueueDataType;

typedef struct QueueNode {
    QueueDataType data;
    struct QueueNode* next;
}QueueNode;

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

void QueueInit(Queue* p) {
    assert(p);
    p->first = p->tail = NULL;
}

bool QueueEmpty(Queue* p) {
    assert(p);
    return p->first == NULL;
}

void QueueDestory(Queue* p) {
    assert(p);
    while (p->first) {
        QueueNode* next = p->first->next;
        free(p->first);
        p->first = next;
    }
}

void QueuePush(Queue* p, QueueDataType x) {
    assert(p);
    QueueNode* new = (QueueNode*)malloc(sizeof(QueueNode));
    if (new == NULL) {
        perror("malloc fail");
        return;
    }
    new->data = x;
    new->next = NULL;
    //尾插
    if (!QueueEmpty(p)) {
        p->tail->next = new;
        p->tail = new;
    } 
    else 
        p->first = p->tail = new;
}

void QueuePop(Queue* p) {
    assert(p);
    assert(!QueueEmpty(p));
    //头删
    if (p->first == p->tail) {
        //只有一个元素
        free(p->first);
        p->first = p->tail = NULL;
    }
    else {
        QueueNode* next = p->first->next;
        free(p->first);
        p->first = next;
    }
}

QueueDataType QueueFront(Queue* p) {
    assert(p);
    assert(!QueueEmpty(p));
    return p->first->data;
}

QueueDataType QueueTail(Queue* p) {
    assert(p);
    assert(!QueueEmpty(p));
    return p->tail->data;
}

//栈的实现
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

MyStack* myStackCreate(){
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x){
    //向非空队列插入数据
    if(QueueEmpty(&obj->q1))
        QueuePush(&obj->q2,x);
    else
        QueuePush(&obj->q1,x);
}

int myStackPop(MyStack* obj){
    //判断空队列和非空队列
    Queue* nonempty = &obj->q1;
    Queue* empty = &obj->q2;
    if(QueueEmpty(&obj->q1)){
        nonempty = &obj->q2;
        empty = &obj->q1;
    }
    //将非空队列的元素除了最后一个，全部移入空队列
    while(nonempty->first != nonempty->tail){
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    //将最后一个元素返回并删除
    int ret = QueueFront(nonempty);
    QueuePop(nonempty);
    return ret;
}
 
int myStackTop(MyStack* obj){
    //返回非空队列的队尾元素
    if(QueueEmpty(obj->q1))
        return QueueTail(&obj->q2);
    else
        return QueueTail(&obj->q1);   

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

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