• 栈&队列OJ练习题(C语言版)

    目录

    一、括号匹配问题

    思路：

    完整版C语言代码：  

    讲解：

    二、用队列实现栈

    思路：

    完整版C语言代码： 

    讲解： 

    三、用栈实现队列

    思路：

    完整版C语言代码：

    讲解：

    四、 设计循环队列

    思路：

    完整版C语言代码：

    讲解：

    如果栈和队列忘了，不妨看看小生的这两篇复习一下数据结构与算法—栈     数据结构与算法—队列

    一、括号匹配问题

    20. 有效的括号 - 力扣（LeetCode）

     

    思路：

    将左括号放入栈中，通过出栈与为入栈的符号进行比较。 

    由于我们用C语言做这道题，所以代码前要加上咱们实现的栈的代码，同时要将数据类型STDataType改为char类型。

    完整版C语言代码：  

    1. typedef char STDataType;
    2. typedef struct Stack
    3. {
    4. 	STDataType* a;
    5. 	int top;
    6. 	int capacity;
    7. }ST;
    8.  
    9. void STInit(ST* pst)
    10. {
    11. 	assert(pst);
    12. 	pst->a = NULL;
    13. 	pst->top = 0;
    14. 	pst->capacity = 0;
    15. }
    16.  
    17. void STDestroy(ST* pst)
    18. {
    19. 	assert(pst);
    20. 	free(pst->a);
    21. 	pst->a = NULL;
    22. 	pst->top = 0;
    23. 	pst->capacity = 0;
    24. }
    25.  
    26. void STPush(ST* pst,STDataType x)
    27. {
    28. 	if (pst->top == pst->capacity) {
    29. 		int newCapacity = pst->capacity == 0 ? 4 :pst-> capacity * 2;
    30. 		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
    31. 		if (tmp == NULL) {
    32. 			perror("realloc fail");
    33. 			return;
    34. 		}
    35. 		pst->a = tmp;
    36. 		pst->capacity = newCapacity;
    37. 	}
    38. 	pst->a[pst->top] = x;
    39. 	pst->top++;
    40. }
    41.  
    42. bool STEmpty(ST* pst)
    43. {
    44. 	assert(pst);
    45. 	return pst->top == 0;
    46. }
    47.  
    48. void STPop(ST* pst)
    49. {
    50. 	assert(pst);
    51. 	assert(!STEmpty(pst));
    52. 	pst->top--;
    53. }
    54.  
    55. STDataType STTop(ST* pst)
    56. {
    57. 	assert(pst);
    58. 	assert(!STEmpty(pst));
    59. 	return pst->a[pst->top - 1];
    60. }
    61.  
    62.  
    63. int STSize(ST* pst)
    64. {
    65. 	assert(pst);
    66. 	return pst->top;
    67. }
    68.  
    69. //------以下为OJ提供-------
    70.  
    71. bool isValid(char* s) {
    72.     ST st;
    73.     STInit(&st);
    74.     while (*s) {
    75.         if (*s == '(' || *s == '[' || *s == '{') {
    76.             STPush(&st, *s);
    77.         }
    78.         else {
    79.             if (STEmpty(&st)) {
    80.                 STDestroy(&st);
    81.                 return false;
    82.             }
    83.             char top = STTop(&st);
    84.             STPop(&st);
    85.             if ((top != '(' && *s == ')') ||
    86.                 (top != '{' && *s == '}') ||
    87.                 (top != '[' && *s == ']')) {
    88.                 STDestroy(&st);
    89.                 return false;
    90.             }
    91.         }
    92.         s++;
    93.     }
    94.     bool ret = STEmpty(&st);
    95.     STDestroy(&st);
    96.     return ret;
    97. }

    讲解：

    isValid函数：

    • 创建栈结构体ST变量 st，然后进行初始化。
    • 以*s为循环进行条件

    • 首先，创建一个名为 st 的 ST 结构体实例，并使用 STInit 初始化它。

    • 然后，遍历输入字符串 s 中的每个字符。
    • 对于每个字符，如果是左括号 '('，'['，'{' ，则将其推入栈中。
    • 如果是右括号 ')'，']'，'}' ，则执行以下操作：

    检查栈是否为空，如果为空，表示没有对应的左括号，则销毁栈，返回 false。

    否则，弹出栈顶元素，将其与当前右括号进行匹配。如果不匹配，则销毁栈，返回 false。

    • 最后，遍历完整个字符串后，检查栈是否为空。如果栈为空，表示所有括号都成功匹配，返回 true，否则返回 false。
    • 最后，调用 STDestroy 销毁栈，并返回最终的匹配结果。

    二、用队列实现栈

    225. 用队列实现栈 - 力扣（LeetCode）

     

    思路：

     准备两个队列，第一个队列依次出队到只剩一个数据时停止，将已出队的数据依次入队到第二个队列，将第一个队列仅剩的一个数据出队即实现了栈的出栈。入栈时哪个队列不为空则在哪个队列入队。

    由于我们用C语言做这道题，所以代码前要加上咱们实现的队列的代码。

    完整版C语言代码： 

    1. typedef int QDataType;
    2. typedef struct QueueNode
    3. {
    4.     struct QueueNode* next;
    5.     QDataType data;
    6. }QNode;
    7.  
    8. typedef struct Queue
    9. {
    10.     QNode* phead;
    11.     QNode* ptail;
    12.     int size;
    13. }Queue;
    14.  
    15. void QueueInit(Queue* pq)
    16. {
    17.     assert(pq);
    18.     pq->phead = NULL;
    19.     pq->ptail = NULL;
    20.     pq->size = 0;
    21. }
    22. void QueueDestroy(Queue* pq)
    23. {
    24.     assert(pq);
    25.     QNode* cur = pq->phead;
    26.     while (cur) {
    27.         QNode* next = cur->next;
    28.         free(cur);
    29.         cur = next;
    30.     }
    31.     pq->phead = pq->ptail = NULL;
    32.     pq->size = 0;
    33. }
    34. void QueuePush(Queue* pq, QDataType x)
    35. {
    36.     assert(pq);
    37.     QNode* newnode = (QNode*)malloc(sizeof(QNode));
    38.     if (newnode == NULL) {
    39.         perror("mallloc fail\n");
    40.         return;
    41.     }
    42.     newnode->data = x;
    43.     newnode->next = NULL;
    44.     if (pq->ptail == NULL) {
    45.         assert(pq->phead == NULL);
    46.         pq->phead = pq->ptail = newnode;
    47.     }
    48.     else {
    49.         pq->ptail->next = newnode;
    50.         pq->ptail = newnode;
    51.     }
    52.     pq->size++;
    53. }
    54. bool QueueEmpty(Queue* pq)
    55. {
    56.     assert(pq);
    57.     return pq->size == 0;
    58. }
    59. void QueuePop(Queue* pq)
    60. {
    61.     assert(pq);
    62.     assert(!QueueEmpty(pq));
    63.     if (pq->phead->next == NULL) {
    64.         free(pq->phead);
    65.         pq->phead = pq->ptail = NULL;
    66.     }
    67.     else {
    68.         QNode* next = pq->phead->next;
    69.         free(pq->phead);
    70.         pq->phead = next;
    71.     }
    72.     pq->size--;
    73. }
    74. QDataType QueueFront(Queue* pq)
    75. {
    76.     assert(pq);
    77.     assert(!QueueEmpty(pq));
    78.     return pq->phead->data;
    79. }
    80. QDataType QueueBack(Queue* pq)
    81. {
    82.     assert(pq);
    83.     assert(!QueueEmpty(pq));
    84.     return pq->ptail->data;
    85. }
    86. int QueueSize(Queue* pq)
    87. {
    88.     assert(pq);
    89.     return pq->size;
    90. }
    91.  
    92. //------以下为OJ提供-------
    93.  
    94. typedef struct {
    95.     Queue q1;
    96.     Queue q2;
    97. } MyStack;
    98.  
    99. MyStack* myStackCreate() {
    100.     MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    101.     if (obj == NULL) {
    102.         perror("malloc fail");
    103.         return NULL;
    104.     }
    105.     QueueInit(&obj->q1);
    106.     QueueInit(&obj->q2);
    107.     return obj;
    108. }
    109.  
    110. void myStackPush(MyStack* obj, int x) {
    111.     if (!QueueEmpty(&obj->q1)) {
    112.         QueuePush(&obj->q1, x);
    113.     }
    114.     else {
    115.         QueuePush(&obj->q2, x);
    116.     }
    117. }
    118.  
    119. int myStackPop(MyStack* obj) {
    120.     Queue* pEmptyQ = &obj->q1;
    121.     Queue* pNonEmptyQ = &obj->q2;
    122.     if (!QueueEmpty(&obj->q1)) {
    123.         pEmptyQ = &obj->q2;
    124.         pNonEmptyQ = &obj->q1;
    125.     }
    126.     while (QueueSize(pNonEmptyQ) > 1) {
    127.         QueuePush(pEmptyQ, QueueFront(pNonEmptyQ));
    128.         QueuePop(pNonEmptyQ);
    129.     }
    130.     int top = QueueFront(pNonEmptyQ);
    131.     QueuePop(pNonEmptyQ);
    132.     return top;
    133. }
    134.  
    135. int myStackTop(MyStack* obj) {
    136.     if (!QueueEmpty(&obj->q1)) {
    137.         return QueueBack(&obj->q1);
    138.     }
    139.     else {
    140.         return QueueBack(&obj->q2);
    141.     }
    142. }
    143.  
    144. bool myStackEmpty(MyStack* obj) {
    145.     return QueueEmpty(&obj->q1) &&
    146.         QueueEmpty(&obj->q2);
    147. }
    148.  
    149. void myStackFree(MyStack* obj) {
    150.     QueueDestroy(&obj->q1);
    151.     QueueDestroy(&obj->q2);
    152.     free(obj);
    153. }

    讲解： 

     1、

    1. typedef struct {
    2.     Queue q1;
    3.     Queue q2;
    4. } MyStack;

    首先在匿名结构体MyStack中设置两个成员 q1、q2，他们的类型为结构体Queue。

    2、

    1. MyStack* myStackCreate() {
    2.     MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    3.     if (obj == NULL) {
    4.         perror("malloc fail");
    5.         return NULL;
    6.     }
    7.     QueueInit(&obj->q1);
    8.     QueueInit(&obj->q2);
    9.     return obj;
    10. }

    myStackCreate中首先创建结构体 MyStack 指针 obj，并为其开辟空间，开辟失败则打印错误信息，然后对 obj 的两个成员 (队列) 进行初始化。

    3、

    1. void myStackPush(MyStack* obj, int x) {
    2.     if (!QueueEmpty(&obj->q1)) {
    3.         QueuePush(&obj->q1, x);
    4.     }
    5.     else {
    6.         QueuePush(&obj->q2, x);
    7.     }
    8. }

    myStackPush中首先判断哪个队列不为空，对不为空的队列进行入队（入栈）。

    4、

    1. int myStackPop(MyStack* obj) {
    2.     Queue* pEmptyQ = &obj->q1;
    3.     Queue* pNonEmptyQ = &obj->q2;
    4.     if (!QueueEmpty(&obj->q1)) {
    5.         pEmptyQ = &obj->q2;
    6.         pNonEmptyQ = &obj->q1;
    7.     }
    8.     while (QueueSize(pNonEmptyQ) > 1) {
    9.         QueuePush(pEmptyQ, QueueFront(pNonEmptyQ));
    10.         QueuePop(pNonEmptyQ);
    11.     }
    12.     int top = QueueFront(pNonEmptyQ);
    13.     QueuePop(pNonEmptyQ);
    14.     return top;
    15. }
    • myStackPop中首先要找到为“空”和“不为空”的队列，假设队列q1为空，q2不为空，通过QueueEmpty判断如果q1为空则假设不变，否则二者互换。
    • 然后将不为空的队列的数据依次入队到为空的队列，入队结束后将不为空的队列进行出队，进行下一次循环，直到不为空的队列只剩一个元素停止循环。
    • 调用QueueFront函数获取队头节点赋值给变量top，将不为空队列仅剩的数据出队。
    • 返回top。

    5、

    1. int myStackTop(MyStack* obj) {
    2.     if (!QueueEmpty(&obj->q1)) {
    3.         return QueueBack(&obj->q1);
    4.     }
    5.     else {
    6.         return QueueBack(&obj->q2);
    7.     }
    8. }

    myStackTop函数找出不为空的队列，对不为空的队列调用QueueBack返回栈顶元素。

    6、

    1. bool myStackEmpty(MyStack* obj) {
    2.     return QueueEmpty(&obj->q1) &&
    3.         QueueEmpty(&obj->q2);
    4. }

    myStackEmpty调用QueueEmpty判断两个队列是否为空即为判断栈是否为空。

    7、

    1. void myStackFree(MyStack* obj) {
    2.     QueueDestroy(&obj->q1);
    3.     QueueDestroy(&obj->q2);
    4.     free(obj);
    5. }

    myStackFree调用 QueueDestroy释放两个队列的内存空间，最后释放栈 obj 的内存空间。

    三、用栈实现队列

    232. 用栈实现队列 - 力扣（LeetCode）

    思路：

    一个栈用于入队，一个栈用于出队。出队栈不为空则从入队栈依次出栈，然后入栈到出队栈，这时原本入队栈的数据在出队栈中直接出栈，即可实现队列的先进先出，再次入队时数据进入入队栈，等待出队栈为空时再将数据倒过来。

     

     由于我们用C语言做这道题，所以代码前要加上咱们实现的栈的代码。

    完整版C语言代码：

    1. typedef int STDataType;
    2. typedef struct Stack
    3. {
    4. 	STDataType* a;
    5. 	int top;
    6. 	int capacity;
    7. }ST;
    8.  
    9. void STInit(ST* pst)
    10. {
    11. 	assert(pst);
    12. 	pst->a = NULL;
    13. 	pst->top = 0;
    14. 	pst->capacity = 0;
    15. }
    16.  
    17. void STDestroy(ST* pst)
    18. {
    19. 	assert(pst);
    20. 	free(pst->a);
    21. 	pst->a = NULL;
    22. 	pst->top = 0;
    23. 	pst->capacity = 0;
    24. }
    25.  
    26. void STPush(ST* pst, STDataType x)
    27. {
    28. 	if (pst->top == pst->capacity) {
    29. 		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
    30. 		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
    31. 		if (tmp == NULL) {
    32. 			perror("realloc fail");
    33. 			return;
    34. 		}
    35. 		pst->a = tmp;
    36. 		pst->capacity = newCapacity;
    37. 	}
    38. 	pst->a[pst->top] = x;
    39. 	pst->top++;
    40. }
    41.  
    42. bool STEmpty(ST* pst)
    43. {
    44. 	assert(pst);
    45. 	return pst->top == 0;
    46. }
    47.  
    48. void STPop(ST* pst)
    49. {
    50. 	assert(pst);
    51. 	assert(!STEmpty(pst));
    52. 	pst->top--;
    53. }
    54.  
    55. STDataType STTop(ST* pst)
    56. {
    57. 	assert(pst);
    58. 	assert(!STEmpty(pst));
    59. 	return pst->a[pst->top - 1];
    60. }
    61.  
    62. int STSize(ST* pst)
    63. {
    64. 	assert(pst);
    65. 	return pst->top;
    66. }
    67.  
    68. //------以下为OJ提供-------
    69.  
    70. typedef struct {
    71. 	ST pushst;
    72. 	ST popst;
    73. } MyQueue;
    74.  
    75. MyQueue* myQueueCreate() {
    76. 	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    77. 	if (obj == NULL) {
    78. 		perror("malloc fail");
    79. 		return 0;
    80. 	}
    81. 	STInit(&obj->pushst);
    82. 	STInit(&obj->popst);
    83. 	return obj;
    84. }
    85.  
    86. void myQueuePush(MyQueue* obj, int x) {
    87. 	STPush(&obj->pushst, x);
    88. }
    89.  
    90. int myQueuePop(MyQueue* obj) {
    91. 	int front = myQueuePeek(obj);
    92. 	STPop(&obj->popst);
    93. 	return front;
    94. }
    95.  
    96. int myQueuePeek(MyQueue* obj) {
    97. 	if (STEmpty(&obj->popst)) {
    98. 		while (!STEmpty(&obj->pushst)) {
    99. 			STPush(&obj->popst, STTop(&obj->pushst));
    100. 			STPop(&obj->pushst);
    101. 		}
    102. 	}
    103. 	return STTop(&obj->popst);
    104. }
    105.  
    106. bool myQueueEmpty(MyQueue* obj) {
    107. 	return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
    108. }
    109.  
    110. void myQueueFree(MyQueue* obj) {
    111. 	STDestroy(&obj->pushst);
    112. 	STDestroy(&obj->popst);
    113. 	free(obj);
    114. }

    讲解：

    1、

    1. typedef struct {
    2. 	ST pushst;
    3. 	ST popst;
    4. } MyQueue;

    在MyQueue结构体中创建两个栈 pushst 和 popst。

    2、

    1. MyQueue* myQueueCreate() {
    2.     MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    3.     if (obj == NULL) {
    4.         perror("malloc fail");
    5.         return 0;
    6.     }
    7.     STInit(&obj->pushst);
    8.     STInit(&obj->popst);
    9.     return obj;
    10. }

    创建一个 MyQueue 类型的队列 obj 。然后通过 malloc 申请内存，如果申请失败则调用perror打印错误信息，结束函数，然后分别初始化 pushst 和 popst 两个栈，返回队列obj。

     3、

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

    将元素 x 入队。直接调用 STPush 函数将元素 x 压入 pushst 栈。

     4、

    1. int myQueuePop(MyQueue* obj) {
    2.     int front = myQueuePeek(obj);
    3.     STPop(&obj->popst);
    4.     return front;
    5. }

    这个函数用于将队首元素出队，并返回其值。首先调用 myQueuePeek 函数获取队首元素的值，然后调用 STPop 函数将元素从 popst 栈中弹出。

    5、 

    1. int myQueuePeek(MyQueue* obj) {
    2.     if (STEmpty(&obj->popst)) {
    3.         while (!STEmpty(&obj->pushst)) {
    4.             STPush(&obj->popst, STTop(&obj->pushst));
    5.             STPop(&obj->pushst);
    6.         }
    7.     }
    8.     return STTop(&obj->popst);
    9. }

    这个函数用于获取队首元素的值。首先判断 popst 栈是否为空，如果为空则将 pushst 栈中的所有元素依次弹出并压入 popst 栈，最后通过 STTop 函数获取 popst 栈顶元素的值。

    6、

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

     这个函数用于判断队列是否为空。只有当 pushst 和 popst 两个栈都为空时，队列才为空。

    7、 

    1. void myQueueFree(MyQueue* obj) {
    2.     STDestroy(&obj->pushst);
    3.     STDestroy(&obj->popst);
    4.     free(obj);
    5. }

    这个函数用于释放 MyQueue 类型队列所占用的内存空间。

    首先调用 STDestroy 函数销毁 pushst 和 popst 两个栈，然后调用 free 函数释放 obj 所占用的内存空间。

    四、 设计循环队列

    622. 设计循环队列

     

     思路：

    选择数组作为循环队列，为了避免队列为空和队列为满时 front 和 rear 相同的情况，将数组的容量设置为比题中要求的队列长度大一（即实际容量为k+1）。

     

    完整版C语言代码：

    1. typedef struct {
    2.     int front;
    3.     int rear;
    4.     int k;
    5.     int* a;
    6. } MyCircularQueue;
    7.  
    8. MyCircularQueue* myCircularQueueCreate(int k) {
    9.     MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    10.     obj->a = (int*)malloc((k + 1) * sizeof(int));
    11.     obj->k = k;
    12.     obj->front = obj->rear = 0;
    13.     return obj;
    14. }
    15.  
    16. bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    17.     return obj->front == obj->rear;
    18. }
    19.  
    20. bool myCircularQueueIsFull(MyCircularQueue* obj) {
    21.     return (obj->rear + 1) % (obj->k + 1) == obj->front;
    22. }
    23.  
    24. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    25.     if (myCircularQueueIsFull(obj)) {
    26.         return false;
    27.     }
    28.     obj->a[obj->rear] = value;
    29.     obj->rear++;
    30.     obj->rear %= (obj->k + 1);
    31.     return true;
    32. }
    33.  
    34. bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    35.     if (myCircularQueueIsEmpty(obj)) {
    36.         return false;
    37.     }
    38.     obj->front++;
    39.     obj->front %= (obj->k + 1);
    40.     return true;
    41. }
    42.  
    43. int myCircularQueueFront(MyCircularQueue* obj) {
    44.     if (myCircularQueueIsEmpty(obj)) {
    45.         return -1;
    46.     }
    47.     return obj->a[obj->front];
    48. }
    49.  
    50. int myCircularQueueRear(MyCircularQueue* obj) {
    51.     if (myCircularQueueIsEmpty(obj)) {
    52.         return -1;
    53.     }
    54.     return obj->a[(obj->rear + obj->k) % (obj->k + 1)];
    55. }
    56.  
    57. void myCircularQueueFree(MyCircularQueue* obj) {
    58.     free(obj->a);
    59.     free(obj);
    60. }

    讲解：

    1、

    1. typedef struct {
    2.     int front;
    3.     int rear;
    4.     int k;
    5.     int* a;
    6. } MyCircularQueue;

    定义MyCircularQueue结构体，front指向队列第一个元素，rear指向队列最后一个元素的下一个位置，k为队列容量，指针a用于动态分配数组存储队列元素。

    2、 

    1. MyCircularQueue* myCircularQueueCreate(int k) {
    2.     MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    3.     obj->a = (int*)malloc((k + 1) * sizeof(int));
    4.     obj->k = k;
    5.     obj->front = obj->rear = 0;
    6.     return obj;
    7. }

    对队列obj开辟空间，为数组a分配k+1个整型元素大小的空间，多出来的一个空间用于区分空队列和满队列，将k的值存储在队列obj中，初始化 front 和 rear 为 0。

    这里将检查队列是否为空或已满的函数从后面移动到这里，方便后续函数能正常调用。 

    3、

    1. bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    2.     return obj->front == obj->rear;
    3. }

    如果front与rear重合，则队列为空。

    4、

    1. bool myCircularQueueIsFull(MyCircularQueue* obj) {
    2.     return (obj->rear + 1) % (obj->k + 1) == obj->front;
    3. }

    通过 (obj->rear + 1) % (obj->k + 1) 计算下一个元素将要插入的位置，如果这个位置和 front 相同，说明队列已满。

    5、

    1. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    2.     if (myCircularQueueIsFull(obj)) {
    3.         return false;
    4.     }
    5.     obj->a[obj->rear] = value;
    6.     obj->rear++;
    7.     obj->rear %= (obj->k + 1);
    8.     return true;
    9. }

    首先检查队列是否已满。

    • 如果满了，返回 false；不满则将数据放入数组的rear位置，然后rear向后移动一位。
    • 如果rear移动到最后一个元素的后一项位置，则通过 obj->rear %= (obj->k + 1); 更新rear的位置。

    6、 

    1. bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    2.     if (myCircularQueueIsEmpty(obj)) {
    3.         return false;
    4.     }
    5.     obj->front++;
    6.     obj->front %= (obj->k + 1);
    7.     return true;
    8. }
    • 首先检查队列是否为空。如果为空，返回 false，
    • 如果不空，更新 front 的值，表示已经移除了一个元素，返回 true。

    7、 

    1. int myCircularQueueFront(MyCircularQueue* obj) {
    2.     if (myCircularQueueIsEmpty(obj)) {
    3.         return -1;
    4.     }
    5.     return obj->a[obj->front];
    6. }
    • 如果队列为空，返回 -1。
    • 如果不空，返回 front 指向的元素。

    8、 

    1. int myCircularQueueRear(MyCircularQueue* obj) {
    2.     if (myCircularQueueIsEmpty(obj)) {
    3.         return -1;
    4.     }
    5.     return obj->a[(obj->rear + obj->k) % (obj->k + 1)];
    6. }
    • 如果队列为空，返回 -1。
    • 如果不空，返回 rear 指向的前一个元素。

     9、

    1. void myCircularQueueFree(MyCircularQueue* obj) {
    2.     free(obj->a);
    3.     free(obj);
    4. }

    释放队列数组 a 和队列结构体的内存空间。

  • 相关阅读:
    va_list 、va_start、va_arg 和 va_end的含义和用法
    电商技术揭秘三十二：智能风控的案例研究与未来趋势
    【Python零基础入门篇 · 7】：列表、元组的相关操作（完整版）
    事件委托代理
    Windows如何ping端口
    工资总额分配方案
    Linux：centos9的本地yum仓库配置
    Mysql高级篇（逻辑架构和存储引擎）
    springmvc总结
    图片上传~
  • 原文地址：https://blog.csdn.net/m0_73800602/article/details/134074974