devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：小丑西瓜9 | 2024-04-17 03:56:10

赞

踩

栈&队列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 和队列结构体的内存空间。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/438081
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号