刷爆Leedcode —— 栈与队列

一、前言

今天我们将会和大家分享一些经典的栈与队列的OJ题目，难度有高有低，我们会从不同的角度为大家解析这些题目，希望对你们有所帮助~~

二、栈与队列OJ题目

1、用队列实现栈

我们先来看看题目的要求，需要我们使用两个队列实现一个后入先出的栈，并支持一些所需要的操作

这里我们肯定是需要一个我们所写过的队列的，那么我们直接从以前写过的队列功能CV过来即可

这里我们可以先画出两个空队列，假设一个队列里面放了1、2、3、4这四个数据，由于栈是后进先出的。如果我们此时需要出数据，那么此时我们出的就是4，也就是我们使用队列的back功能就能取到这个数值。但这边有一个问题，pop这个我们该如何实现呢？一般来说数列只能pop对头，而这里需要我们删除并返回栈顶元素。这个时候我们就需要用到我们一开始开辟的另外一个空队列，我们将数据1、2、3导入到这个空队列中，那么剩余的4就相当于栈顶元素，把他pop掉就可以达到要求了。如果还需要pop的话，那么就是以此类推导数据了。

可能有人会问，这样的话不是会导致效率低下吗？在我看来这道题是不考虑效率的，主要考察的是栈和队列的性质，栈和队列的性质是相反的。

Note ：这里需要注意一点，当我们需要再次插入数据的时候，我们需要将数据插入到不为空的那一个队列中，因为我们始终需要一个空队列用于导数据。

具体的代码实现如下:

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;  

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;                                                                                                       
}Queue;

// 初始化队列 
void QueueInit(Queue* pq);      
// 队尾入队列 
void QueuePush(Queue* pq, QDataType data);
// 队头出队列 
void QueuePop(Queue* pq);
// 获取队列头部元素 
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数 
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq);
// 销毁队列 
void QueueDestroy(Queue* pq);

// 初始化队列 
void QueueInit(Queue* pq)
{   
    assert(pq);                        
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode; 
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	
	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

int QueueEmpty(Queue* pq)
{
	assert(pq);
    
	return pq->head == NULL && pq->tail == NULL;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}

	pq->head = pq->tail = NULL;
}

typedef struct {
    Queue q1;
    Queue q2;
}MyStack;


MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonEmpty = &obj->q1;
    }

    //将非空数列的前N-1个导入空队列，剩下一个就是栈顶元素
    while(QueueSize(nonEmpty) > 1)
    {
        QueuePush(empty, QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }
    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    
    free(obj);
}

之所以看起来又长又复杂是因为C语言里面没有队列的库，所以需要我们自己写一个队列以及其功能出来，所以这里有一个小技巧，我们可以将我们所写的诸如栈、队列、链表等放在一个文件夹里，方便我们做题的时候直接使用。

2、用栈实现队列

这一题和上一题恰恰相反，题目要求我们使用两个栈实现一个先入先出的队列并且完成一系列功能

同样的，我们需要一个栈以及具有的功能供我们使用，这一段大家可以套用以前实现的栈

这里我们先给出两个空栈，假设将其分别命名pushST和popST。当我们入数据的时候我们就先导入到pushST这个栈里面，出数据的时候我们就利用popST出数据。这里有一个问题可能大家会有所疑惑：在出完数据之后如果popST里还有剩余数据我们需不要需要把剩余数据导回pushST这个栈？因为如果不进行这个操作的话再将pushST的数据导入过来就会产生一个出入栈的顺序问题。这里的答案是不用，我们需要知道栈导来导去的顺序是反的，导回去当然可以使得顺序这个问题得以解决，但有没有这个必要呢？事实上是没有，因为我们只需要等popST里的数据pop完了我们再导入pushST里面的数据，也就是说我们是允许两边的栈都是有数据的。

具体代码实现如下：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}ST;

// 初始化栈 
void StackInit(ST* ps);
// 入栈 
void StackPush(ST* ps, STDataType data);
// 出栈 
void StackPop(ST* ps);
// 获取栈顶元素 
STDataType StackTop(ST* ps);
// 获取栈中有效元素个数 
int StackSize(ST* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(ST* ps);
// 销毁栈 
void StackDestroy(ST* ps);

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

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int NewCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* cur = (STDataType*)realloc(ps->a, NewCapacity * sizeof(STDataType));
		if (cur == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = cur;
		ps->capacity = NewCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

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

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

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

	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}


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

typedef struct { 
    ST pushST;
    ST 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);
}

void PushSTTOPopST(MyQueue* obj)
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
}

int myQueuePop(MyQueue* obj) {
    PushSTTOPopST(obj);

    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}

int myQueuePeek(MyQueue* obj) {
    PushSTTOPopST(obj);
    
    return StackTop(&obj->popST);
}

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

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->popST);
    StackDestroy(&obj->pushST);

    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);
*/

3、设计循环队列

这一题目的难度明显是要高于前两题的，它的思路也更为巧妙，接下来让我们好好剖析它。

首先题目要求我们实现一个循环队列，其实这就相当于一个环形结构，但是在我们实际实现的过程中我们无法实现一个环状的结构。我们只能通过链表或者数组来实现，我将会用数组来为大家展示我的实现过程。

由于题目中要求我们实现删除插入等功能，我们除了在结构体里面开辟一个数组以外，我们还需要两个指针，一个头一个尾，以及一个表示数组长度的N。

这两个指针我们将其分别命名为front和back，front肯定就是队头了。

首先我们最先需要实现的就是判空和判满，也就是IsEmpty和IsFull这两个函数，其实很简单，我们需要明确back指向的并不是尾部，而是尾部元素的下一个位置。也就是我们每插入一个数据back就会往后面移动一个位置。有了这一认识，我们很容易就可以得到当front和back处于同一个位置时数组为空的这一结论。 但是这里就又有一个问题了，我们发现判满的时候front和back这两个指针也是处在同一个位置的，那我们该如何去解决呢？这里我会提供两种思路，这第一种思路就是我们添加一个size，当size=0的时候自然就是空了，而当size等于实际长度的时候就是满了。第二种方案就是增加一个空间，这个空间不存储数据，也就是满的时候永远留一个空的位置，比如长度是4，我们就开5个空间。这么做的意义是什么呢？

我们可以画一张图来分析：

我们可以看到这是我们存放数据的地方已经满了，back现在所处的位置就是我们多开辟的一个空间，这样我们就可以很清晰的判断当back的下一个位置是front的时候该数组就满了。这个思路比size的思路更为巧妙，大家可以借鉴一下。

当然，这个新开的空间也给我们其他功能的实现带来了新的问题：当我们进行删除等操作的时候，如果back位于这个空的位置的时候我们该如何处理呢？其实也很简单，我们只需要让他模上数组的长度就可以了，如果不处于新开空间位置的话，这个操作并没有影响，而当back处于新开空间位置的时候，模上数组的长度就使得back的位置回到了0。

具体代码实现如下：

typedef struct {
    int* a;
    int front;
    int back;
    int N;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int) * (k + 1));
    obj->front = obj->back = 0;
    obj->N = k + 1;

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back + 1) % obj->N == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }

    obj->a[obj->back] = value;
    obj->back++;

    obj->back %= obj->N;

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }

    obj->front++;
    obj->front %= obj->N;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->back - 1 + obj->N) % obj->N];
    }
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

三、总结：

这三道题目从不同角度考察了栈和队列的问题，我们从中可以看到两者的相似性以及相异性，尤其是一二两题的正反应用，让我们对其有了更为深刻的理解。而第三题的解题思路更为综合，需要我们利用到以前的知识以及一些解题技巧，希望大家都可以从中得到一些启发，感谢大家的支持！