【万字详解栈和队列及其OJ题】

已于 2023-02-09 15:00:36 修改
阅读量484 收藏 25
点赞数 40
分类专栏： 初阶数据结构 文章标签： 数据结构 c语言 栈和队列 leetcode
于 2022-08-19 12:41:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68872612/article/details/126393678
版权

各位大佬们，今天分享的是栈和队列的实现以及相关OJ题，如果觉得不错的话能支持一下菜鸟吗？

目录

一 栈

1.1 栈的概念及结构

1.2 栈的实现

 二 队列

2.1队列的概念及结构

 2.2队列的实现

三 栈与队列的OJ练习

3.1 括号匹配问题

3.2 用队列实现栈

3.3 用栈实现队列

 3.4 设置循环队列

一 栈

1.1 栈的概念及结构


栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶
 

 

 

1.2 栈的实现

实现栈的方式一般有两种：顺序表和链表。

但用顺序表实现栈较为优，原因有如下：

1 栈都是从栈顶插入数据以及删除数据，用链表实现不好尾删（如果尾删时间复杂度为O(N)）

2 链表每次开辟空间时都会有消耗，而动态顺序表一次可以malloc几倍的空间大小
 

1cc9388784c74b2c84f827eea14b3a29.png

 接下来就用动态顺序表来实现栈：

1 结构体类型的声明：

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

这里用了一个STDataType*的指针指向了一个动态开辟的空间，top记录栈顶的位置，以及空间容量的大小。

2 各接口函数的声明：

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

3 判断栈是否为空：

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

用其他方法也行，这种方法比较简单。

4 初始化栈：

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

5 销毁栈：

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

6 入栈：

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp =(STDataType*) realloc(ps->a, sizeof(STDataType)* newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

7 出栈：

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

删除时要注意当栈为空时就不要删除了。

8 得到栈顶的元素：

STDataType stackTop(ST* ps)
{
	return ps->a[ps->top-1];
}

由于初始化时top置为0，而每次push完后top++,所以要得到栈顶的元素就必须让top-1，当然如果初始化时top置为-1，就不需要-1了，但是push数据的代码也得做出相应的调整。

我们可以用个测试函数来测试一下上面接口是否有误：

bf7955e25d75483b8232614573b11339.png

 经过分析可知应该是没多大问题的。写这种多种接口的最好的方法是写完一个就测试一个，这样出了问题也能更快的调试分析出来问题所在。

是不是感觉栈其实也没有那么难，这些玩法都是我们之前顺序表和链表玩过的，下面我们来做两个栈的概念题来巩固一下：

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的
顺序是（ ）。
A 12345ABCDE
B EDCBA54321
C ABCDE12345
D 54321EDCBA
 

这个题选B，没啥好说的

4.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1
 

 这种题就一个一个带入，首先看A ：1进栈然后出栈，然后2 3 4，进栈，以4 3 2出栈，符合题意。B ： 1 2进栈，2出栈，3 4进栈，以3 4 1出栈，符合题意。 C： 1 2 3进栈，3出栈，4进栈，但是出栈必须是4先出，所以不符合。 D： 1 2 3进栈，3出栈，4进栈，4出栈，最后2 1出栈，符合题意。所以本题选C

 二 队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾   出队列：进行删除操作的一端称为队头
 

fd251b0ddfdd4192b47c4c2d9e36b15c.png

 2.2队列的实现


与栈类似，队列也可以数组和链表的结构实现，但是队列使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

 

 接下来就用顺序表实现队列：

1 结构体类型的声明：

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
    int sz;
}Queue;

这里定义了一个tail的目的是为了更方便在队尾删除数据，而通常定义两个不同的量我们又喜欢放在一个结构体上。

2 各接口函数的声明：

bool QueueEmpty(Queue* pq);
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);

3 判断队列是否为空：

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

 只要有一个不为空那么队列就不为空，所以用&&。

4 初始化队列：

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

5 销毁队列：

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

销毁栈最后别忘了将head和tail置为空，否则就留下了隐患。

6 队尾入数据：

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->val = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
    pq->sz++;
}

这里要讨论head和tail都为空的情况，否则就会出错。

7 队头删数据：

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
    pq->sz--;
}

同理删除数据时队列不能为空，但是要注意当head为空时也要把tail置为空，这样才能避免对野指针的访问。

8 得到队头元素：

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

同理，队头不能为空。

9 得到队尾元素：

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->val;
}

10 队列长度：

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->sz;
}

我们可以测试一下接口是否有误：

350ac0f177524aa4864fa86a3e5f6625.png

三 栈与队列的OJ练习

3.1 括号匹配问题

题目描述：

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
 

示例 1：

输入：s = "()"
输出：true


示例 2：

输入：s = "()[]{}"
输出：true


示例 3：

输入：s = "(]"
输出：false


示例 4：

输入：s = "([)]"
输出：false


示例 5：

输入：s = "{[]}"
输出：true
 

提示：

1 <= s.length <= 104
s 仅由括号 '()[]{}' 组成

解题思路：

这是一个经典用栈解决问题的题目，先让左括号入栈，当取到右括号时就出栈，拿这个左括号与右括号匹配，若能够成功匹配就接着迭代，否则就返回false,当全部元素都取完了的时候都没有返回false时就返回true.但是还要考虑栈不为空的情况。

具体代码：

typedef char 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);
bool StackEmpty(ST* ps);

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

void StackDestroy(ST* ps)
{
	free(ps->a);
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp =(STDataType*) realloc(ps->a, sizeof(STDataType)* newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

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

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


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

bool isValid(char * s)
{
    ST ps;
	StackInit(&ps);
    //遍历
    while(*s)
      {
        if(*s=='(' || *s=='[' || *s=='{')
         {
            StackPush(&ps,*s);
            s++;
         }
        else
          {//遇到了右括号，但是栈里面没有数据，说明前面没有左括号，不匹配返回false
              if(StackEmpty(&ps))
              {
                    StackDestroy(&ps);//返回前记得销毁，否则造成内存泄漏
                    return false; 
              }
             STDataType top=StackTop(&ps);
             StackPop(&ps);
             //这里用不匹配来判断更为方便
             if((*s==')' && top!='(')
             || (*s==']' && top!='[')
             || (*s=='}' && top!='{'))
                 {
                    StackDestroy(&ps);//返回前记得销毁，否则造成内存泄漏
                    return false; 
                 }
                 s++;
          }
       }
       //如果栈不是为空就返回false
      bool ret=StackEmpty(&ps);
       StackDestroy(&ps);//返回前记得销毁，否则造成内存泄漏
       return ret;
}

题中值得注意的地方我都用了注释进行了说明，一定要注意否则代码可能就会编不过。

73847f9797144517870509b790fc4c63.png

3.2 用队列实现栈

题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
 

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
 

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]


输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False
 

提示：

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空
 

解题思路：

让其中一个空队列保存数据，然后再让该队列一个一个从队头出数据保存到另外一个队列中，直至最后一个数据，再pop掉，然后迭代下去。

具体代码实现：

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueueDestroy(Queue* pq);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->val = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

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

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}


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

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->val;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	if (QueueEmpty(pq))
		return 0;
	QueueNode* cur = pq->head;
	int count = 0;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

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

MyStack* myStackCreate() {
MyStack* tmp=(MyStack*)malloc(sizeof(MyStack));


    QueueInit(&tmp->q1);
    QueueInit(&tmp->q2);
    return tmp;

}

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

int myStackPop(MyStack* obj) {
Queue* emptyQ=&obj->q1;
Queue* unemptyQ=&obj->q2;
if(QueueEmpty(&obj->q2))
{
     emptyQ=&obj->q2;
     unemptyQ=&obj->q1;
}
while(QueueSize(unemptyQ)>1)
{
    QueuePush(emptyQ,QueueFront(unemptyQ));
    QueuePop(unemptyQ);
}
int top=QueueFront(unemptyQ);
QueuePop(unemptyQ);
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);
obj=NULL;
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

这里面分装了两个队列q1和q2,具体如何初始化 push pop可以参照上面我写的接口，free时记得把q1和q2都destroy掉，不然会造成内存泄漏。

b32aab0efdb441bbb8aa95a00fb11ffa.png

3.3 用栈实现队列

题目描述：

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

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


说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
 

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]


输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
 

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
 

解题思路;

与用队列实现栈相同，我们仍然要分装两个栈pushSt和popSt,往pushSt中push数据，当pop时就把pushSt中的数据一个一个导过去，此时popST中数据就符合先进后出。

具体代码实现：

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);
bool StackEmpty(ST* ps);

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

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

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

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp =(STDataType*) realloc(ps->a, sizeof(STDataType)* newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
		}
		ps->a = tmp;
		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)
{
	return ps->a[ps->top-1];
}
typedef struct {
ST pushSt;
ST popSt;
} MyQueue;


MyQueue* myQueueCreate() {

MyQueue *ps=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&ps->pushSt);
StackInit(&ps->popSt);
return ps;
}

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) {
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);
}

void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->pushSt);
StackDestroy(&obj->popSt);
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);
*/

结果展示：

b85ec3f71be54562975c22433a51d538.png

 3.4 设置循环队列

再介绍该题之前我们得了解一下什么是循环队列？

 

 

循环队列无论使用数组实现还是链表实现，较优的方法是多开辟一个空间，否则就无法实现判空和判满。（当然你用一个整形变量记录当前有效数据长度也是可行的，只不过用多开一个单位这种方法比较优）

题目描述：

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
 

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4
 

提示：

所有的值都在 0 至 1000 的范围内；
操作数将在 1 至 1000 的范围内；
请不要使用内置的队列库。

解题思路：

这个题用链表和数组都可以，这儿用的是数组解题（这个题用数组比链表简单不少），让front和tail分别指向相对数据的头和尾，但是要注意当front和tail超过了k+1时的处理方法，可以用判断，也可以用%来处理。如果是在搞不懂%,用判断也是一种比较好的方法。

具体代码：

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

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	cq->a = (int*)malloc(sizeof(int) * (k + 1));
	cq->front = cq->tail = 0;
	cq->k = k;
	return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (myCircularQueueIsFull(obj))
		return false;
	obj->a[obj->tail] = value;
	obj->tail++;
	obj->tail %= (obj->k + 1);
	return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
		return false;
	obj->front++;
	obj->front %= (obj->k + 1);
	return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
		return -1;
	if (obj->tail == 0)
		return obj->a[obj->k];
	else
		return obj->a[obj->tail - 1];
}

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

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

void myCircularQueueFree(MyCircularQueue* obj) {
	free(obj->a);
	obj->a = NULL;
	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);
*/

结果展示：

8fb5b5560a12487ebfb7e6e0fe92082b.png

好了，今天的分享就到这里了，如果觉得该文对你有帮助的话能不能支持一下博主呢？

16cc7067dd7943aa87ed59fe672e571f.png

Fox！
关注
  • 40
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 40
    评论
专栏目录
手动开大栈
gankinghand的博客
08-12 3143
今天打题的时候发现在本机爆栈（一条链，300000），但是oj上不怕，于是上网查了一下，其实现在NOI系列赛的栈已经和和规定空间一起算，也就是说不用再打人工栈，但是本机调试怎么办？ c++，工具，编译选项，在编译时加入以下命令 -Wl,--stack=134217728 不用打人工栈，暴爽...
如何手动开大系统栈？
weixin_30700977的博客
08-23 910
Dev-c++:手动开大系统栈，防止爆栈 在各大OJ上，系统栈都会开大，而在本地调试时，常用到云端下载的各种毒瘤数据，一不小心就可能在本机上爆掉系统栈，在oj上却没事。 Devc++：工具->编译选项->选择编译时加入以下命令->输入： -Wl,--stack=134217728 Dev-c++神奇操作，请看： 第一次安装Dev-c++编译器如何设置...
手工扩栈的方法
Warren's Blog
07-09 486
#pragma comment(linker, "/STACK:102400000,102400000")//手动开大栈区
c++本机手动加栈
jz_terry的博客
04-21 716
在本机调试的时候，经常会出现爆栈的问题，那是因为本机的栈比OJ上的要小很多。如果不想打人工栈，那就可以复制上以下代码进行手动加栈，调节本机上栈的上限。int size = 1024 &lt;&lt; 20; // 1024MB  char *p = (char*)malloc(size) + size;  __asm__("movl %0, %%esp\n" :: "r"(p));  这是1024...
OJ提交题目中的语言选项里G++与C++的区别
Welcome ! This is Guanpx's blog.
02-10 846
今天poj又出现了 G++ Wa C++ Ac 的情况 特转学习 原文地址见最后 一、OJ提交题目中的语言选项里G++与C++的区别 http://www.th7.cn/Program/cp/201405/199001.shtml 首先更正一个概念，C++是一门计算机编程语言，G++不是语言，是一款编译器中编译C++程序的命令而已。 那么他们之间的区别是什么？ 在提交
栈和队列oj详解
JJR_YZ的博客
09-09 864
万字详解栈和队列oj题，图文分析并茂。
万字文详解二叉树OJ面试题
m0_62547912的博客
10-01 606
二叉树常见oj题思路讲解
【C++】STL——stack和queue（万字详解）
m0_60338933的博客
10-27 2619
对STL的栈和队列的详解
C语言回文数OJ题和答案
10-22
打印所有小于65536且是完全平方数的回文数。
蓝桥杯历届题目和测试数据（oj建设题库）
02-19
因为有测试数据，也可以输入到您自己的oj系统里面，补充题库，或者作为出题的参考。 http://www.lanqiao.org/ 关于蓝桥 蓝桥网是一个帮助泛IT领域人士学习、就业及职业成长的立体式、综合性服务平台。平台业务...
Python凯撒密码OJ题和答案
06-15
Python凯撒密码OJ题的题目和答案。手打代码。 描述 凯撒密码是古罗马凯撒大帝用来对军事情报进行加解密的算法，它采用了替换方法对信息中的每一个英文字符循环替换为字母表序列中该字符后面的第三个字符，即，字母表...
Python棋盘放米OJ题和答案
07-24
Py棋盘放米OJ的题目和答案。 问题描述 相传古代印度国王舍罕要褒赏他的聪明能干的宰相达依尔 （国际象棋发明者）， 问他需要什么，达依尔回答说：“国王只要在国际象棋的棋盘第一个格子里放一粒麦子， 第二个格子里...
OJ系统蓝桥杯题库
12-03
OJ系统的蓝桥杯题库，http://oj.xpuca.top/，这里有这些题的栗子。
55. 跳跃游戏
SHUOSHUREN233的博客
06-21 217
题目：给你一个非负整数数组 nums ，你最初位于数组的 第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标，如果可以，返回 true；否则，返回 false。本题我的思路是使用int型变量num储存最后一个下标，从最后一个元素往前退，当前面的元素下标加元素值大于等于num时，更新num为当前元素下标，最后判断num是否为0。
数据结构实训：表达式求值器（非常详细）
最新发布
2301_79783133的博客
06-22 787
数据结构实训：表达式求值，非常详细的代码解释
数据结构-线性表的顺序表示
pyc68的博客
06-22 869
本篇文章介绍线性表的基本概念，并使用顺序存储结构实现线性表。
左式堆(数据结构篇)
hellmorning的博客
06-21 363
讲述数据结构中的左式堆
R语言——数据结构与数据处理
weixin_66547608的博客
06-21 802
mat1的数据是1:6，3行2列的形式。（1）编写一个函数调用apply函数族，让矩阵mat1的每一个元素都减去矩阵mat1的最大值，并输出。创建一个list列表，列表中包括两个向量、两个矩阵、一个数据框、两个函数（fun1、fun2）。打印出列表中的各个元素，并调用函数fun1、fun2，输出相应的打印结果。（2）生成一个1 1 2 2 3 3的向量。数据科学与大数据技术21-2。数据科学与大数据技术21-2。数据科学与大数据技术21-2。数据科学与大数据技术21-2。数据科学与大数据技术21-2。
杭电oj分类.docx
03-07
杭电oj分类

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 40
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值