leetcode 232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

思路：
一个栈pushST专门用来入数据，一个栈popST专门用来出数据；入队就向pushST栈入栈；出队就从popST中出栈，当popST中为空时，将pushST中所有数据依次出栈再入栈到popST中，然后popST出栈一个数据。

//实现一个栈
typedef int SDataType;

//栈结构体
typedef struct Stack
{
	SDataType* ps;
	int top;
	int capacity;
}Stack;

//队列结构体
typedef struct {
    Stack pushST;
    Stack popST;
} MyQueue;

//栈初始化
void StackInit(Stack* p);

//检查容量
void CheckCapacity(Stack* p);

//入栈
void StackPush(Stack* p,SDataType x);

//出栈
void StackPop(Stack* p);

//获取栈顶元素
SDataType StackTop(Stack* p);

//获取栈中有效数据个数
int StackSize(Stack* p);

//判断栈是否为空
int StackEmpty(Stack* p);

//销毁栈
void StackDestory(Stack* p);

//栈初始化
void StackInit(Stack* p)
{
	assert(p);
	p->ps = NULL;
	p->top = 0;
	p->capacity = 0;
}

//入栈
void StackPush(Stack* p, SDataType x)
{
	assert(p);

	if (p->top == p->capacity)
	{
		//扩容
		int newcapacity = p->capacity == 0 ? 4 : p->capacity*2;

		SDataType* tmp = (SDataType*)realloc(p->ps,sizeof(SDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		//扩容成功
		p->ps = tmp;
		p->capacity = newcapacity;
	}

	p->ps[p->top] = x;
	p->top++;
}

//出栈
void StackPop(Stack* p)
{
	assert(p);

	assert(p->top >0);

	p->top--;
}

//获取栈顶元素
SDataType StackTop(Stack* p)
{
	assert(p);
	assert(p->top >0);
	return p->ps[p->top - 1];
}

//获取栈中有效数据个数
int StackSize(Stack* p)
{
	assert(p);
	return p->top;
}

//判断栈是否为空
int StackEmpty(Stack* p)
{
	assert(p);

	return p->top > 0 ? 0 : 1;
}

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

//创建队列
MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

//入队
void myQueuePush(MyQueue* obj, int x) 
{
	assert(obj != NULL);
    StackPush((&obj->pushST),x);
}

//出队并返回
int myQueuePop(MyQueue* obj) 
{
	assert(obj != NULL);
	
	assert( !StackEmpty(&(obj->pushST)) || (!StackEmpty(&(obj->popST))) );
	//如果PopST为空
    if(StackEmpty(&obj->popST))
    {
    	//PushST出栈，PopST入栈
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }    
    }
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}

//返回队头数据
int myQueuePeek(MyQueue* obj) 
{
	assert(obj != NULL);
	
	assert( !StackEmpty(&(obj->pushST)) || (!StackEmpty(&(obj->popST))) );
	
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
        
    }
    return StackTop(&obj->popST);
}

//队列是否为空
bool myQueueEmpty(MyQueue* obj)
 {
	assert(obj != NULL);
    return StackEmpty(&obj->popST) && StackEmpty(&obj->pushST);
}

//销毁队列
void myQueueFree(MyQueue* obj)
 {
	assert(obj != NULL);
    StackDestory(&obj->popST);
    StackDestory(&obj->pushST);
    free(obj);
}