// 支持动态增长的栈
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	ps->capacity = 5;
	ps->a = (STDataType*)malloc(sizeof(STDataType)*ps->capacity);
	if (!ps->a)
	{
		assert(0);
	}
	ps->top = 0;
}
//检查容量，不够增加
void CheckCapacity(Stack *ps)
{
	if (ps->top >= ps->capacity)
	{
		ps->capacity = 2 * ps->capacity;
		ps->a = (STDataType*)realloc(ps->a,sizeof(STDataType)*ps->capacity);
		if (!ps->a)
		{
			assert(0);
		}
	}
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	return 0 == ps->top;
}
bool StackFull(Stack *ps)
{
    return ps->top==ps->capacity;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//事先检查容量
	CheckCapacity(ps);
	//入栈
	ps->a[ps->top] = data;
	ps->top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	//事先检查是否为空
	if (StackEmpty(ps))
		return;
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	//事先检验是否为空
	if (StackEmpty(ps))
	{
		return (STDataType)0;
	}
	return ps->a[ps->top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	return ps->top;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//--------------以上是栈的实现-----------------
typedef struct 
{
    Stack s1;//入队列
    Stack s2;//出队列
} MyQueue;
MyQueue* myQueueCreate() 
{
    MyQueue *obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(!obj)
    {
        assert(0);
        return NULL;
    }
    StackInit(&obj->s1);
    StackInit(&obj->s2);
    return obj;
}
//入队
void myQueuePush(MyQueue* obj, int x) 
{
    //向s1中入栈
    if(StackFull(&obj->s1))
    {
        return;
    }
    else
    {
        StackPush(&obj->s1,x);
    }
}
//出队
int myQueuePop(MyQueue* obj) 
{
    int ret=0;
    if(StackEmpty(&obj->s2))
    {
        if(StackEmpty(&obj->s1))
        {
            return 0;
        }
        while(!StackEmpty(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }

    }
    ret=StackTop(&obj->s2);
    StackPop(&obj->s2);
    return ret;
}
//获取队头
int myQueuePeek(MyQueue* obj) 
{
    int ret=0;
    if(StackEmpty(&obj->s2))
    {
        if(StackEmpty(&obj->s1))
        {
            return 0;
        }
        while(!StackEmpty(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
    }
    ret=StackTop(&obj->s2);
    return ret;
}

bool myQueueEmpty(MyQueue* obj) 
{
    if(StackEmpty(&obj->s1)&&StackEmpty(&obj->s2))
    {
        return true;
    }
    return false;
}

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

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