225.Implement Stack using Queues(C语言版本)

Implement the following operations of a stack using queues.

• push(x) -- Push element x onto stack.
• pop() -- Removes the element on top of the stack.
• top() -- Get the top element.
• empty() -- Return whether the stack is empty.

Notes:

• You must use only standard operations of a queue -- which means only push to back, peek/pop from front, size, and is empty operations are valid.
• Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
• You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

解题思路：

因为是C语言版本，所以要想实现用两个队列去实现一个栈，需要将队列的操作实现。

结构体的构建(难点)

 

typedef struct{
    int *q;
    int size;
    int front;
    int rear;
}Queue;

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

int queueIsEmpty(Queue *q){
    if(q->front == -1 && q->rear == -1)
    {
        return 1;
    }
    return 0;
}

int queueIsFull(Queue *q){
    if(q->rear == q->size-1)
    {
        return 1;
    }
    return 0;
}

int queueTop(Queue *q)
{
    if(queueIsEmpty(q))
    {
        return -1;
    }
    return q->q[q->front];
}

int queuePop(Queue *q){
    if(queueIsEmpty(q))
    {
        return -1;
    }
    int item = q->q[q->front];
    if(q->front == q->rear)
    {
        q->front = q->rear = -1;
    }else
    {
        q->front++;
    }
    return item;
}

void queuePush(Queue *q,int val)
{
    if(queueIsFull(q))
    {
        printf("\nQueue is Full \n");
        return;
    }
    if(queueIsEmpty(q))
    {
        q->front++;
        q->rear++;
    }else
    {
        q->rear++; 
    }
    q->q[q->rear] = val;
}
Queue *queueCreate(int maxSize)
{
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->front = q->rear = -1;
    q->size = maxSize;
    q->q = (int *)malloc(sizeof(int)*maxSize);
    return q;
}

/** Initialize your data structure here. */
MyStack* myStackCreate(int maxSize) {
    MyStack *s = (MyStack *)malloc(sizeof(MyStack));
    s->q1 = queueCreate(maxSize);
    s->q2 = queueCreate(maxSize);
    return s;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    queuePush(obj->q2,x);
    while(!queueIsEmpty(obj->q1))
    {
        int item = queuePop(obj->q1);
        queuePush(obj->q2,item);
    }
    Queue *tmp = obj->q1;
    obj->q1 = obj->q2;
    obj->q2 = tmp;
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    if(queueIsEmpty(obj->q1))
    {
        return -1;
    }
    return queuePop(obj->q1);
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    if(!queueIsEmpty(obj->q1))
    {
        return queueTop(obj->q1);
    }
    return -1;
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    if(queueIsEmpty(obj->q1))
    {
        return true;
    }
    return false;
}

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

/**
 * Your MyStack struct will be instantiated and called as such:
 * struct MyStack* obj = myStackCreate(maxSize);
 * myStackPush(obj, x);
 * int param_2 = myStackPop(obj);
 * int param_3 = myStackTop(obj);
 * bool param_4 = myStackEmpty(obj);
 * myStackFree(obj);
 */