《数据结构》力扣题目 1.用队列实现栈 2.用栈实现队列 3.设计循环队列 详解，内附动图解释
目录
一. 225. 用队列实现栈
题目链接：
题目：用队列实现栈
题目讲解：
完整代码实现：
二.232. 用栈实现队列
题目链接：
题目：
题目讲解：
完整代码实现：
三.622. 设计循环队列
题目链接：
题目：
题目讲解：
完整代码实现：
一. 225. 用队列实现栈
题目链接：
225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com)
题目：用队列实现栈
请你仅使用两个队列实现一个后入先出（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 都保证栈不为空
题目讲解：
前提是先有各种队列函数供使用！
0.先创建一个结构体 MyStack (这个结构体变量就是我们创建的“栈”)，“栈”中包含q1，q2两个队列，核心思想是：q1，q2中保持一个队列存储数据，另外一个队列空着；要出栈时，空队列用来倒数据，下面有出栈示意图(因为 队列是先进先出，栈是先进后出，所以主要是出栈需要改造)
typedef struct {
Queue q1;
Queue q2;
} MyStack;
出栈示意图：假设开始q1中有1,2,5三个值，q2为空队列 ; 最终q1前N-1个数据给q2，最后一个数据删掉，实现了栈的后进先出(或者先进后出)
逐个分析“栈”对应功能的函数：
1.创建栈：先开辟一块 MyStack 类型的空间并赋值给 指针pst，同时断言检查是否为NULL，再把此空间中的两个队列变量q1和q2都用队列初始化函数进行初始化，并返回这个地址pst
MyStack* myStackCreate() {
MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
assert(pst);
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}2.入栈： q1和q2一个是空的队列，一个是存数据的队列，方便后面出栈，通过 QueuePush 队列插入函数(相当于单链表尾插) 将数据给到不为空的队列中，因为刚开始都是空队列，所以给q1或q2都行，当其中一个为非空队列时，再次尾插就会尾插到这个非空队列中
void myStackPush(MyStack* obj, int x) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);
}
}
3.出栈：把不为空的队列的数据前N-1导入另一个空队列,最后剩下的一个删掉。
前面先找出空队列 emptyQ 和非空队列 nonEmptyQ ，讲空队列的前N-1个数据导入另一个空队列,最后剩下的一个删掉。
int myStackPop(MyStack* obj) {
assert(obj);
Queue* emptyQ=&obj->q1;
Queue* nonEmptyQ=&obj->q2;
if(!QueueEmpty(&obj->q1))
{
emptyQ=&obj->q2;
nonEmptyQ=&obj->q1;
}
while(QueueSize(nonEmptyQ)>1)
{
QDataType front=QueueFront(nonEmptyQ);
QueuePush(emptyQ,front);
QueuePop(nonEmptyQ);
}
QDataType top=QueueFront(nonEmptyQ);
QueuePop(nonEmptyQ);
return top;
}4.找"栈"的栈顶：即最后一个结点的值，哪个队列不为空，就返回哪个队列的末尾节点的值。
int myStackTop(MyStack* obj) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}5.判断“栈”是否为空：只要q1和q2两个队列全为空队列就返回true
bool myStackEmpty(MyStack* obj) {
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}6.释放“栈”：销毁q1，q2两个队列，并free“栈”的地址空间即可
void myStackFree(MyStack* obj) {
assert(obj);
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
}完整代码实现：
typedef int QDataType;
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
}Queue;
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = NULL;
pq->tail = NULL;
}
void QueueDestory(Queue* pq) //复盘！！！
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->head =pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
assert(newnode);
newnode->next = NULL;
newnode->data = x;
if (pq->tail == NULL)
{
assert(pq->head==NULL);
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode; //写的时候漏了！！！
}
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->head && pq->tail);
if (pq->head == pq->tail)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
//return pq->head == NULL && pq->tail == NULL;
return pq->head == NULL;
}
size_t QueueSize(Queue* pq)
{
assert(pq);
size_t size = 0;
QNode* cur = pq->head;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->tail);
return pq->tail->data;
}
//——————————————————————————————————————————————————————以上是队列的操作
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
assert(pst);
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}
void myStackPush(MyStack* obj, int x) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);
}
}
int myStackPop(MyStack* obj) {
assert(obj);
Queue* emptyQ=&obj->q1;
Queue* nonEmptyQ=&obj->q2;
if(!QueueEmpty(&obj->q1))
{
emptyQ=&obj->q2;
nonEmptyQ=&obj->q1;
}
while(QueueSize(nonEmptyQ)>1)
{
QDataType front=QueueFront(nonEmptyQ);
QueuePush(emptyQ,front);
QueuePop(nonEmptyQ);
}
QDataType top=QueueFront(nonEmptyQ);
QueuePop(nonEmptyQ);
// if(!QueueEmpty(&obj->q2))
// printf("1111111");
// if(!QueueEmpty(&obj->q2))
// printf("2222222");
return top;
}
int myStackTop(MyStack* obj) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
bool myStackEmpty(MyStack* obj) {
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
assert(obj);
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
}
二.232. 用栈实现队列
题目链接：
232. 用栈实现队列 - 力扣（LeetCode） (leetcode-cn.com)
题目：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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 操作）
题目讲解：
前提是先有各种 栈函数 供使用！
0.这是第一题的兄弟题，跟上面操作差不多，唯一不同是不用来回倒数据(下面核心思想讲)，这里也是先创建一个结构体 MyQueue (这个结构体变量就是我们创建的“队列”)，“队列”中包含 pushST ，popST两个队列，核心思想是：因为 队列是先进先出，栈是先进后出，所以肯定主要还是改造 "出队列" ，把pushST中的数据拿到popST中是倒序，再出栈达到删除原顺序第一个数据的目的，即出队列的操作。
typedef struct {
ST pushST;
ST popST;
} MyQueue;
1.创建“队列”函数：malloc一块MyQueue的空间obj (这个结构体变量就是我们创建的“队列”)，初始化其中的两个栈，并返回这个“队列”的地址。
MyQueue* myQueueCreate() {
MyQueue* obj=( MyQueue*)malloc(sizeof( MyQueue));
assert(obj);
StackInit(&obj->pushST);
StackInit(&obj->popST);
return obj;
}2.“队列”插入函数：就直接往pushST中插入就行了
void myQueuePush(MyQueue* obj, int x) {
assert(obj);
StackPush(&obj->pushST, x);
}3.“队列”删除函数：如果popST中无数据就不能删数据，需要从pushST中拿数据，当pushST中有数据才能拿，如果pushST中有数据 1,2,3,4，先用 StackTop(&obj->pushST) 找到pushST中的尾数据 4，再通过 StackPush(&obj->popST, StackTop(&obj->pushST)); 把这个数据放到popST中，再用 StackPop(&obj->pushST); 删掉pushST里的尾数据 4，一直这样重复到pushST中数据拿完，此时popST中数据就是4,3,2,1，输出并删除pushST的尾数据 1 就达到了删除原顺序 1,2,3,4 中的首数据1，进而达到了出队列的效果 。(如下动图所示)
int myQueuePop(MyQueue* obj) {
assert(obj);
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;
}
如果一直出队列，删除1->删除2->删除3->删除4,删完了，如果又用 myQueuePush 添加了数据(例如5,6,7,8)，就依旧把pushST中的数据出栈到popST中，再输出删除popST中的尾数据(如下动图)
上图就相当于
如果pushST也没数据，if条件进去后不进while条件，就结束了。
4.找“队列”头数据函数：如果popST空，也要从pushST拿数据，跟上面函数操作一样，最后返回popST尾数据，相当于原顺序数据的头数据。
int myQueuePeek(MyQueue* obj) {
assert(obj);
if(StackEmpty(&obj->popST))
{
while(!StackEmpty(&obj->pushST))
{
StackPush(&obj->popST, StackTop(&obj->pushST));
StackPop(&obj->pushST);
}
}
return StackTop(&obj->popST);
}
5.判断“队列是否为空”函数：两个栈都是空，则整个“队列”就为空。
bool myQueueEmpty(MyQueue* obj) {
assert(obj);
return StackEmpty(&obj->pushST)&& StackEmpty(&obj->popST);
}6.释放函数：销毁两个栈，最后因为 myQueueCreate() 函数malloc的obj结构体空间，最后也要free(obj);
void myQueueFree(MyQueue* obj) {
assert(obj);
StackDestory(&obj->pushST);
StackDestory(&obj->popST);
free(obj);
}完整代码实现：
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
STDataType StackTop(ST* ps);
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
void StackDestory(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;
ps->a = (STDataType*)realloc(ps->a,sizeof(STDataType)*newcapacity);
if (ps->a == NULL)
{
printf("realloc fail\n");
exit(-1);
}
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
void StackPop(ST* ps) //StackTop+StackPop => 出栈
{
assert(ps);
assert(ps->top>0);
--ps->top;
}
bool StackEmpty(ST* ps)
{
assert(ps);
//if (ps->top > 0)
// return false;
//else
// return true;
return ps->top == 0;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(ps->top > 0);
return ps->a[ps->top - 1];
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
//————————————————————————————————————————————————————————————————以上是栈操作
typedef struct {
ST pushST;
ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* obj=( MyQueue*)malloc(sizeof( MyQueue));
assert(obj);
StackInit(&obj->pushST);
StackInit(&obj->popST);
return obj;
}
void myQueuePush(MyQueue* obj, int x) {
assert(obj);
StackPush(&obj->pushST, x);
}
int myQueuePop(MyQueue* obj) {
assert(obj);
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) {
assert(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) {
assert(obj);
return StackEmpty(&obj->pushST)&& StackEmpty(&obj->popST);
}
void myQueueFree(MyQueue* obj) {
assert(obj);
StackDestory(&obj->pushST);
StackDestory(&obj->popST);
free(obj);
}三.622. 设计循环队列
题目链接：
622. 设计循环队列 - 力扣（LeetCode） (leetcode-cn.com)
题目：
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 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. 次循环队列有数组和单链表两个底层结构，该选哪一个呢？
答：选数组较好。实际上两者各有优劣，其实都差不多，
选数组的原因：
数组的优点：(也是单链表的缺点) 因为tail只能指向末尾数据的下一个地址，如果要找尾结点数据时，单链表找tail的上一个节点很费劲，数组就只需要tail-1就能找到。
数组的缺点：(也是单链表的优点) 如果是数组结构，当tail到最后一个节点时，为了成为循环队列结构，需要手动让tail=0，单链表就不用手动赋值。
0.0 创建结构体 MyCircularQueue ，包含数组队列int* a，整形front代表队列头部的角标，tail代表队列尾部的角标，k代表能存几个数据
typedef struct {
int* a;
int front;
int tail;
int k;
} MyCircularQueue;接下来逐一分析我们创建的循环队列对应的各个函数：
1.创建循环队列函数：开辟一个循环队列的结构体的空间，地址名叫obj，通过下面动态图①发现：最开始front=tail=0，每增加一个数据，tail++，当增加k个(假设k=4)数据时，tail又不得不回到角标0处，此时front=tail=0，这样空列表和慢列表无法区分，(图②)为了避免空和满混淆，多开一个空间，front == tail时是空，tail的下一个位置是front就是满
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->a=(int*)malloc(sizeof(int)*(k+1));
obj->front=obj->tail=0;
obj->k=k;
return obj;
}图①
图②
2.入“队列”函数：“队列”结构体：
typedef struct {
int* a;
int front;
int tail;
int k;
} MyCircularQueue;
通常是将value赋给数组队列的最后一个值，然后tail++即可，但是也应考虑 满队列 和 tail走到头（obj->tail=k）两种情况：满队列应提前用 myCircularQueueIsFull(obj) 判断队列是否满的函数，如果是true，说明队列已满，返回布尔值false说明添加失败；当tail走到头，obj->tail==obj->k 成立，就将tail置为0，达到队列循环的作用，否则就是正常情况，直接obj->tail++即可。最终返回布尔值true说明添加成功。
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
assert(obj);
obj->a[obj->tail]=value;
if(myCircularQueueIsFull(obj))
return false;
if(obj->tail==obj->k)
obj->tail=0;
else
obj->tail++;
return true;
}3.“队列”删除函数：队列是头删，正常情况是质疑删一个，obj->front++即可，但要考虑到“空队列”和front走到头 两种情况：提前利用下面的判空函数 myCircularQueueIsEmpty(obj) ，如果此函数为true，说明队列为空，不能再删除，return false，表明删除失败；front走到头时，即obi->front==obj->k成立，就把front置为0，达到循环的目的，否则为正常情况，直接obj->front++即可，只要删除成功，就return true。
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
assert(obj);
if(myCircularQueueIsEmpty(obj))
return false;
if(obj->front==obj->k)
{
obj->front=0;
}
else
{
obj->front++;
}
return true;
}4.查找“队列”头部数值的函数：如果是空队列就返回-1（题目要求），不空就返回数组队列头部的那个值。
int myCircularQueueFront(MyCircularQueue* obj) {
assert(obj);
if( myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
}5.查找“队列”尾部数值的函数：如果是空队列就返回-1（题目要求），因为tail是最后一个数据的下一个结点的地址，所以不空也有两种情况：如果obj->tail是整个队列的第一个数据的角标，那他的上一个数据就是尾数据，因为当obj->tail=obj->k时，再添加数据，tail因为循环又要回到头部，即obj->tail=0，这个情况就直接返回尾数据 obj->a[obj->k] 即可。否则就是正常情况，返回tail位置的上一个值即可。
int myCircularQueueRear(MyCircularQueue* obj) {
assert(obj);
if( myCircularQueueIsEmpty(obj))
return -1;
if(obj->tail==0)
return obj->a[obj->k];
else
return obj->a[obj->tail-1];
}6.检查“队列”是否为空函数：当front和tail相等时，说明队列为空。
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
assert(obj);
return obj->front==obj->tail;
}7.检查“队列”是否已满 函数：正常情况是：当tail的下一个位置的角标和front相等时，即为满队列。但考虑特殊情况 obj->tail=obj->k 时，tail的下一个位置是头坐标，所以就是obj->tail=obj->k的同时obj->front=0，也是满队列的情况。要考虑全！
bool myCircularQueueIsFull(MyCircularQueue* obj) {
assert(obj);
if(obj->tail==obj->k && obj->front==0)
return true;
return obj->tail+1==obj->front;
}
8.释放“队列” 函数：释放两个空间，分别是结构体“队列”中的数组a，其实就是结构体obj本身的空间也要释放。
void myCircularQueueFree(MyCircularQueue* obj) {
assert(obj);
free(obj->a);
free(obj);
}完整代码实现：
typedef struct {
int* a;
int front;
int tail;
int k;
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->a=(int*)malloc(sizeof(int)*(k+1));
obj->front=obj->tail=0;
obj->k=k;
return obj;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
assert(obj);
obj->a[obj->tail]=value;
if(myCircularQueueIsFull(obj))
return false;
if(obj->tail==obj->k)
obj->tail=0;
else
obj->tail++;
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
assert(obj);
if(myCircularQueueIsEmpty(obj))
return false;
if(obj->front==obj->k)
{
obj->front=0;
}
else
{
obj->front++;
}
return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
assert(obj);
if( myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj) {
assert(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) {
assert(obj);
return obj->front==obj->tail;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
assert(obj);
if(obj->tail==obj->k && obj->front==0)
return true;
return obj->tail+1==obj->front;
}
void myCircularQueueFree(MyCircularQueue* obj) {
assert(obj);
free(obj->a);
free(obj);
}