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

各位大佬们，今天分享的是栈和队列的实现以及相关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几倍的空间大小
 

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

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数据的代码也得做出相应的调整。

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

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

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

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) 入队列：进行插入操作的一端称为队尾   出队列：进行删除操作的一端称为队头
 

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

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

---

三 栈与队列的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;
}

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

---

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掉，不然会造成内存泄漏。

---

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

结果展示：

---

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

结果展示：

---

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