LeetCode题目: 循环队列与用栈实现队列

🎵 把青春献给身后那座辉煌的都市, 把爱情留给我身边最真心的姑娘 .

---

一. 前言

“大部分学生与马克思所描述的工人十分相似, 马克思所描述的工人是为了生存, 不得不出卖劳动力, 机械的重复固定的工作, 大部分学生, 也可以说是为了未来的生存, 不得不去学校每周重复地上规定的课, 工人的劳动工资因为竞争加剧, 就不断压低, 学生的分数标准, 因竞争加剧被不断抬高, 工人只有延长劳动时间或加大工作强度, 才能多得一点工资以维持生活, 学生只有延长学习时间或加大学习强度, 才能多考一点分数以保障升学, 人们总说学生有这样的问题那样的问题, 在我看来, 有时候也不能怪学生自己, 而在客观上, 我们的教育, 不是倾向于把他培养成人, 而是倾向于把他驯化为奴.”

本篇文章旨在如何实现循环队列这一结构和如何使用栈实现队列.
更多文章, 博客主页: 酷酷学!!!
感谢关注~

---

二. 循环队列

题目链接: 设计循环队列

题目描述:

题目思路:

通过一个定长数组实现循环队列
入队：首先要判断队列是否已满，再进行入队的操作，入队操作需要考虑索引循环的问题，当索引越界，需要让它变成最小值
出队：首先要判断队列是否为空，再进行出队操作，出队也需要考虑索引循环的问题
判空： 队头 == 队尾
判满： 队尾 + 1 == 队头

队列是一种先进先出的线性结构, 上一章节我们使用了链表实现队列, 因为链表对于尾插和头删比较友好, 但是对于环形队列, 如果我们使用链表, 并没有数组那么简单, 比如队列已满的情况下, 如何与队列为空的情况进行区别, 那如果我们使用数组呢, 定义两个下标, 为了使队空的状态与队满的状态进行区分, 让队尾下标指向有效元素的下一个节点, 当然也可以定义一个size变量记录有效元素个数, 但是都避免不了取模运算, 所以也不需要额外定义size, 使用数组实现环形链表也不需要挪动数据, 我们多开辟一个空间大小, 插入元素只需要让队尾指针加一, 删除元素只需要让对头指针加一, 开始时, 队尾指针和队头指针指向同一位置, 队列满时队头指针的下一个位置恰好就是队尾指针.

代码如下:

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->a = (int*)malloc(sizeof(int)*(k+1));//多开辟一个空间大小
    q->head = 0;
    q->tail = 0;
    q->k = k;
    return q;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->head == obj->tail)//如果对头指针与队尾指针指向同一个位置, 则队列为空
    {
        return true;
    }
    return false;
    
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //两种情况 tail的下一个位置是head,如下代码分析
    if((obj->tail+1) % (obj->k+1) == obj->head)
    {
        return true;
    }
    return false;
    
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    obj->tail = (obj->tail) % (obj->k+1);//当tail指向最后一个下标时,进行循环
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    obj->head = (obj->head) % (obj->k+1);//进行循环
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->tail+obj->k) % (obj->k+1)];//分为两种情况, 看代码解析

}



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

代码分析:

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //两种情况 tail的下一个位置是head
    if((obj->tail+1) % (obj->k+1) == obj->head)
    {
        return true;
    }
    return false;
    
}

以上两种情况都为满, 使用 (obj->tail+1) % (obj->k+1) == obj->head 如果队尾指针指向最后一个位置, 则取模计算出的下一个位置恰好为0下标

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->tail+obj->k) % (obj->k+1)];//分为两种情况, 看代码解析

}

如果为一下这种情况, 或者正常情况, 进行取模运算, 都可以计算出前一个位置下标.
(obj->tail+obj->k) % (obj->k+1)

三. 用栈实现队列

题目链接: 用栈实现队列

题目描述:

题目思路:

此题可以用两个栈实现，一个栈进行入队操作，另一个栈进行出队操作
出队操作： 当出队的栈不为空是，直接进行出栈操作，如果为空，需要把入队的栈元素全部导入到出队的栈，然后再进行出栈操作

上一章节, 我们使用了队列来实现栈, 本次我们使用栈来实现队列, 两道题的思路都是差不多的, 本题使用两个栈实现队列, 我们可以让一个栈进行插入操作, 另一个栈进行出队列操作, 插入元素到pushst中, 如果需要删除元素, 先判断popst是否为空, 为空的话把pushst中所有元素导入到popst中, 只需要导一次, 然后如果不为空, 只需要pop出栈顶元素.

画图演示:

代码如下:

typedef int STDataType;

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

//初始化和销毁
void STInit(ST* pst);
void Destroy(ST* pst);

//入栈和出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);

//判空
bool STEmpty(ST* pst);

//获取数据个数
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	//指向栈顶数据的下一个位置
	pst->top = 0;
	pst->capacity = 0;
}
void Destroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

//入栈和出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		int newCapacity = pst->capacity==0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("malloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top>0);
	pst->top--;
}

//取栈顶数据
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top-1];
}

//判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

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


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

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

int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(STSize(&obj->pushst)>0)
        {
            int tmp = STTop(&obj->pushst);
            STPop(&obj->pushst);
            STPush(&obj->popst,tmp);
        }
    }
    int ret = STTop(&obj->popst);
    STPop(&obj->popst);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
        if(STEmpty(&obj->popst))
    {
        while(STSize(&obj->pushst)>0)
        {
            int tmp = STTop(&obj->pushst);
            STPop(&obj->pushst);
            STPush(&obj->popst,tmp);
        }
    }
    int ret = STTop(&obj->popst);
    return ret;
}

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

void myQueueFree(MyQueue* obj) {
    Destroy(&obj->popst);
    Destroy(&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);
*/

四. 总结

循环队列是通过数组实现的一种队列结构，在数组中利用头尾指针来标记队列的起始和结束位置。相比于普通队列，循环队列可以更好地利用数组空间，避免空间浪费。循环队列的主要操作包括入队和出队，入队时需要考虑循环队列满的情况，出队时需要考虑循环队列空的情况。循环队列的时间复杂度为O(1)。

用栈实现队列是通过两个栈来模拟队列的操作。其中一个栈用于入队操作，另一个栈用于出队操作。入队时将元素压入入队栈中，出队时先判断出队栈是否为空，若为空则将入队栈的元素全部转移到出队栈中，然后从出队栈中出栈一个元素。用栈实现队列的时间复杂度为O(1)，但在某些特定情况下，需要将所有元素从一个栈转移到另一个栈，导致最坏情况下的时间复杂度为O(n)。

循环队列适用于需要频繁进行入队和出队操作的场景，特别是在空间有限的情况下，循环队列可以更好地利用数组空间。而用栈实现队列适用于需要进行大量的出队操作，相对于循环队列，用栈实现队列的出队操作更加高效。此外，使用两个栈实现队列还可以实现队列的反转操作，即将队列中的元素逆序排列。

---

完