LeetCode题解|232.用栈实现队列

用栈实现队列

用C语言实现本题需要先自己实现栈，这里我直接拷贝课堂上实现栈的代码

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

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


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//或者ps->top = -1;
	//初始化时，top=0意味着top指向栈顶数据的下一个(先放数据再++)；
	//-1意味着top指向栈顶(先++再放数据)
	ps->capacity = 0;
}

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

void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc failn");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

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

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	//assert(ps->top > 0);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);

	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}

	return ps->top == 0;
}

下面解释如何用两个栈来实现队列的思路

需要两个栈，一个pushST用来入数据，另一个popST用来出数据。
需要入队就直接往pushST中入栈；
需要出队的时候就从popST出栈，如果popST为空则先把pushST中的数据全部转移到popST中再出栈。

结构定义

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;

初始化

MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

入队

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

出队

int myQueuePop(MyQueue* obj) {
    //如果popST中没有数据，则将pushST中得数据导过去
    //popST中得数据就符合先进先出了
    if(StackEmpty(&obj->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) {
    //如果popST中没有数据，则将pushST中得数据导过去
    //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) {
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

销毁(先销毁内层，实际上有3层结构，但是对栈的内部已经封装，我们只看得见两层)

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

C语言不适合刷题，数据结构需要自己实现。

本题主要利用了栈的先入后出（后入先出）的特点，利用一个临时栈popST就可以实现队列的先入先出的效果。

每次入队的时间复杂度为O(1)。
出队考虑到需要从pushST转到popST中的最坏情况，时间复杂度为O(n)。

而链表实现的队列入队出队时间复杂度都是O(1)。

注意多层结构先释放内层空间。