232. Implement Queue using Stacks(C语言版本)（Time Limit Exceeded）

Implement the following operations of a queue using stacks.

• push(x) -- Push element x to the back of queue.
• pop() -- Removes the element from in front of queue.
• peek() -- Get the front element.
• empty() -- Return whether the queue is empty.

Notes:

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

typedef struct{
    int *data;
    int size;
    int top;
}Stack;

typedef struct {
    Stack *s1;
    Stack *s2;
} MyQueue;

int stackIsEmpty(Stack *s){
    if(s->top == -1)
    {
        return 1;
    }
    return 0;
}

int stackIsFull(Stack *s){
    if(s->size-1 == s->top)
    {
        return 1;
    }
    return 0;
}

int stackPeek(Stack *s)
{
    if(stackIsEmpty(s))
    {
        return -1;
    }
    return s->data[s->top];
}

int stackPop(Stack *s)
{
    if(stackIsEmpty)
    {
        return -1;
    }
    int item = s->data[s->top];
    s->top--;
    return item;
}

void stackPush(Stack *s,int val)
{
    if(stackIsFull)
    {
        return;
    }
    s->top++;
    s->data[s->top] = val;
}

Stack *stackCreate(int maxSize)
{
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (int *)malloc(maxSize*sizeof(int));
    s->top = -1;
    s->size = maxSize;
    return s;
}

/** Initialize your data structure here. */
MyQueue* myQueueCreate(int maxSize) {
    MyQueue * obj = (MyQueue *)malloc(sizeof(MyQueue));
    obj->s1 = stackCreate(maxSize);
    obj->s2 = stackCreate(maxSize);
    return obj;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    Stack *a,*b;
    a = obj->s1;
    b = obj->s2;
    if(a->top + b->top >= a->size-2)
        return;
    b->top++;
    b->data[b->top] = x;
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    Stack *a,*b;
    a = obj->s1;
    b = obj->s2;
    
    int temp;
    if(a->top>-1)
    {
        temp = a->data[a->top];
        a->top--;
    }else
    {
        while(b->top>-1)
        {
            stackPush(a,stackPop(b));
        }
        if(a->top>-1)
        {
            temp = a->data[a->top];
            a->top--;
        }else
        {
            return -1;
        }
    }
    return temp;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    Stack *a,*b;
    a = obj->s1;
    b = obj->s2;
    
    int temp;
    if(a->top>-1)
    {
        temp = a->data[a->top];
    }else
    {
        while(b->top>-1)
        {
            stackPush(a,stackPop(b));
        }
        if(a->top>-1)
        {
            temp = a->data[a->top];
        }else
        {
            return -1;
        }
    }
    return temp;
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    Stack *a,*b;
    a = obj->s1;
    b = obj->s2;
    if(stackIsEmpty(a) && stackIsEmpty(b))
    {
        return true;
    }else
    {
        return false;
    }
}

void myQueueFree(MyQueue* obj) {
    free(obj->s1);
    free(obj->s2);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * struct MyQueue* obj = myQueueCreate(maxSize);
 * myQueuePush(obj, x);
 * int param_2 = myQueuePop(obj);
 * int param_3 = myQueuePeek(obj);
 * bool param_4 = myQueueEmpty(obj);
 * myQueueFree(obj);
 */