用栈实现队列

用栈实现队列：题目链接
栈：链接
队列：链接

思路

用两个栈实现队列：
一个栈负责入队列，一个栈负责实现出队列。出队列时，如果负责出队列的栈为空，则将另一个栈的数据倒入其中；如若有数据则直接出即可

代码实现

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//top所标识的是最后一个数据的下一个位置
	int capacity;
}Stack;

void StackInit(Stack* ps);
void StackDestroy(Stack* ps);
void StackPush(Stack* ps, STDataType x);
void StackPop(Stack* ps);
void Stackp(Stack* ps);
STDataType StackTop(Stack* ps);
bool StackEmpty(Stack* ps);
int StackSize(Stack* ps);

void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int  newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果栈中没有数据，那么给它四个数据的空间；如果有，那么在原有的基础上扩大二倍
		STDataType* temp = realloc(ps->a, sizeof(STDataType) * newCapacity);//用temp指向扩容后的空间，回头再把它赋给ps->a
		if (temp == NULL)//realloc可能会失败，失败会返回空指针
		{
			printf("realloc fail\n");
			exit(-1); 
		}
		ps->a = temp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

bool StackEmpty(Stack* ps)
{
	assert(ps);
	//if (ps->top > 0)
	//{
	//	return false;
	//}
	//else
	//{
	//	return true;
	//}
	return ps->top == 0;
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue *obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst, x);
}

int myQueuePop(MyQueue* obj) {
    if (StackEmpty(&obj->popst))//如果pop栈为空，则把push栈的数据倒过去
    {
        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) {
    if (StackEmpty(&obj->popst))//如果pop栈为空，则把push栈的数据倒过去
    {
        while (!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst, StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }    
    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst) && StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);
    free(obj);
}