• 队列的实现和OJ练习（c语言）

    目录

    概念

    队列的实现

    利用结构体存放队列结构

    为什么单链表不使用这种方法？

    初始化队列

    小提示：

    队尾入队列

    队头出队列

    获取队头元素

    获取队尾元素

    获取队列中有效元素个数

    检测队列是否为空

    销毁队列

    最终代码

    循环队列 

    队列的OJ题

    用队列实现栈

    用栈实现队列

    概念

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

    队列的实现

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

    利用结构体存放队列结构

            我们之前在实现单链表的时候使用到了二级指针来达到修改头尾结点的效果，这样会增加代码复杂性和理解难度......

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. //链式结构：表示队列
    8. typedef int QDataType;
    9. typedef struct QueueNode
    10. {
    11. 	QDataType val;
    12. 	struct QueueNode* next;
    13. }QNode;
    14.  
    15. //队列的结构（使用结构体避免了二级指针的使用）
    16. typedef struct Queue
    17. {
    18. 	QNode* phead;
    19. 	QNode* ptail;
    20. 	int size;        //存放队列大小
    21. }Queue;

            现在我们依然选择用单链表实现队列，但是我们将指向链表的头尾结点的指针信息都存放在一个结构体中，这样就起到了简化参数传递的作用。即在初始化队列时只需分配一个包含头尾节点、队列大小等信息的结构对象，并将其作为参数传递给相关函数。这样就可以直接通过访问该结构对象中的相应成员变量来修改或获取所需信息

    为什么单链表不使用这种方法？

            这是因为在单链表中，使用结构体来表示整个单链表可能会带来一些不必要的复杂性，并且没有明显的好处，相比于这种方法使用二级指针会有以下有点：

    1. 简化插入和删除操作：由于插入或删除操作需要调整前后两个节点之间的连接关系（而队列不需要考虑在指定位置插入的问题），将头尾结点分别存放在结构体中可能需要更多额外处理步骤才能保持正确连接关系。

    2. 节省内存空间：如果每个节点都包含了头尾信息，则会导致额外占用内存空间，并且增加了维护数据一致性所需付出成本。

    3. 降低复杂度：通过仅保存对首元素（即头部）进行引用，在大多数情况下足以满足对单链表进行各种操作所需求。这样可以简化代码逻辑并提高代码可读性与可维护性。

    初始化队列

    1. //初始化队列
    2. void QueueInit(Queue* pq)
    3. {
    4. 	assert(pq);
    5. 	pq->phead = pq->ptail = NULL;
    6. 	pq->size = 0;
    7. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、有效则将队列初始化为空队列，即将指向队头元素和队尾元素的指针及队列元素个数都置为空

    小提示：

    这个看不看都行

    队尾入队列

    1. //队尾入队列
    2. void QueuePush(Queue* pq, QDataType x)
    3. {
    4. 	assert(pq);
    5.  
    6. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
    7. 	if (newnode == NULL)
    8. 	{
    9. 		perror("malloc fail");
    10. 		return;
    11. 	}
    12.  
    13. 	newnode->val = x;
    14. 	newnode->next = NULL;
    15.  
    16. 	if (pq->ptail == NULL)
    17. 	{
    18. 		pq->ptail = pq->phead = newnode;
    19. 	}
    20. 	else
    21. 	{
    22. 		pq->ptail->next = newnode;
    23. 		pq->ptail = newnode;
    24. 	}
    25.  
    26. 	pq->size++;
    27. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、malloc申请新的结点空间，并进行开辟失败的判断

    3、若开辟成功则向链表结点中插入有效数据，以及下一个结点的置空

    4、检测队列是否为空，若为空则将新申请的结点作为队列的第一个元素，令指向队头和队尾的指针指向该元素

    5、若不为空，则将指向队尾元素的指针指向新元素，同时将指向队尾的指针向后移动指向该元素

    6、完成一次队尾入队操作后，将队列元素个数加一

    队头出队列

    1. // 对头出队列
    2. void QueuePop(Queue* pq)
    3. {
    4. 	assert(pq);
    5. 	
    6. 	assert(pq->phead);
    7.  
    8. 	QNode* del = pq->phead;
    9. 	pq->phead = pq->phead->next;
    10. 	free(del);
    11. 	del = NULL;
    12.  
    13. 	if (pq->phead == NULL)
    14. 		pq->ptail = NULL;
    15.  
    16. 	pq->size--;
    17. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、利用断言检测队列头元素不为空

    3、利用临时指针变量删除队头结点，并将指向队头结点指针向后移动，最后释放该指针并置空

    4、队头元素出队列后，若头指针变为空，则将尾指针也变为空

    获取队头元素

    1. //获取队头元素
    2. QDataType QueueFront(Queue* pq)
    3. {
    4. 	assert(pq);
    5. 	// 
    6. 	assert(pq->phead);
    7.  
    8. 	return pq->phead->val;
    9. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、利用断言检测队列头元素不为空

    3、返回此时队头元素的值

    获取队尾元素

    1. //获取队头元素
    2. QDataType QueueFront(Queue* pq)
    3. {
    4. 	assert(pq);
    5. 	// 
    6. 	assert(pq->phead);
    7.  
    8. 	return pq->phead->val;
    9. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、利用断言检测队列头元素不为空

    3、返回此时队尾元素的值

    获取队列中有效元素个数

    1. //获取队列中有效元素个数
    2. int QueueSize(Queue* pq)
    3. {
    4. 	assert(pq);
    5.  
    6. 	return pq->size;
    7. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、返回结构体中的size值

    检测队列是否为空

    1. //检测队列是否为空
    2. bool QueueEmpty(Queue* pq)
    3. {
    4. 	assert(pq);
    5.  
    6. 	return pq->phead == NULL;
    7. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、返回对pq->phead == NULL的判断结果，返回结果为真则队列为空，为假则队列非空

    销毁队列

    1. //销毁队列
    2. void QueueDestroy(Queue* pq)
    3. {
    4. 	assert(pq);
    5.  
    6. 	QNode* cur = pq->phead;
    7. 	while (cur)
    8. 	{
    9. 		QNode* next = cur->next;
    10. 		free(cur);
    11. 		cur = next;
    12. 	}
    13.  
    14. 	pq->phead = pq->ptail = NULL;
    15. 	pq->size = 0;
    16. }

    实现步骤： 

    1、利用断言检测队列指针的有效性

    2、遍历每一个队头元素并销毁，最后将头尾指针及队列元素数量均置为空

    最终代码

    Queue.h文件

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. //链式结构：表示队列
    8. typedef int QDataType;
    9. typedef struct QueueNode
    10. {
    11. 	QDataType val;
    12. 	struct QueueNode* next;
    13. }QNode;
    14.  
    15. //队列的结构（使用结构体避免了二级指针的使用）
    16. typedef struct Queue
    17. {
    18. 	QNode* phead;
    19. 	QNode* ptail;
    20. 	int size;
    21. }Queue;
    22.  
    23. //初始化队列
    24. void QueueInit(Queue* pq);
    25.  
    26. //队尾入队列
    27. void QueueDestroy(Queue* pq);
    28.  
    29. //队头出队列
    30. void QueuePush(Queue* pq, QDataType x);
    31.  
    32. //获取队头元素
    33. void QueuePop(Queue* pq);
    34.  
    35. //获取队尾元素
    36. QDataType QueueFront(Queue* pq);
    37.  
    38. //获取队列中有效元素个数
    39. QDataType QueueBack(Queue* pq);
    40.  
    41. //检测队列是否为空
    42. bool QueueEmpty(Queue* pq);
    43.  
    44. //销毁队列
    45. int QueueSize(Queue* pq);

    Queue.c文件

    1. #include"Queue.h"
    2.  
    3. //初始化队列
    4. void QueueInit(Queue* pq)
    5. {
    6. 	assert(pq);
    7. 	pq->phead = pq->ptail = NULL;
    8. 	pq->size = 0;
    9. }
    10.  
    11. //销毁队列
    12. void QueueDestroy(Queue* pq)
    13. {
    14. 	assert(pq);
    15.  
    16. 	QNode* cur = pq->phead;
    17. 	while (cur)
    18. 	{
    19. 		QNode* next = cur->next;
    20. 		free(cur);
    21. 		cur = next;
    22. 	}
    23.  
    24. 	pq->phead = pq->ptail = NULL;
    25. 	pq->size = 0;
    26. }
    27.  
    28. //队尾入队列
    29. void QueuePush(Queue* pq, QDataType x)
    30. {
    31. 	assert(pq);
    32.  
    33. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
    34. 	if (newnode == NULL)
    35. 	{
    36. 		perror("malloc fail");
    37. 		return;
    38. 	}
    39.  
    40. 	newnode->val = x;
    41. 	newnode->next = NULL;
    42.  
    43. 	if (pq->ptail == NULL)
    44. 	{
    45. 		pq->ptail = pq->phead = newnode;
    46. 	}
    47. 	else
    48. 	{
    49. 		pq->ptail->next = newnode;
    50. 		pq->ptail = newnode;
    51. 	}
    52.  
    53. 	pq->size++;
    54. }
    55.  
    56. // 对头出队列
    57. void QueuePop(Queue* pq)
    58. {
    59. 	assert(pq);
    60. 	// 
    61. 	assert(pq->phead);
    62.  
    63. 	QNode* del = pq->phead;
    64. 	pq->phead = pq->phead->next;
    65. 	free(del);
    66. 	del = NULL;
    67.  
    68. 	if (pq->phead == NULL)
    69. 		pq->ptail = NULL;
    70.  
    71. 	pq->size--;
    72. }
    73.  
    74. //获取队头元素
    75. QDataType QueueFront(Queue* pq)
    76. {
    77. 	assert(pq);
    78. 	// 
    79. 	assert(pq->phead);
    80.  
    81. 	return pq->phead->val;
    82. }
    83.  
    84. //获取队尾元素
    85. QDataType QueueBack(Queue* pq)
    86. {
    87. 	assert(pq);
    88. 	// 
    89. 	assert(pq->ptail);
    90.  
    91. 	return pq->ptail->val;
    92. }
    93.  
    94. //检测队列是否为空
    95. bool QueueEmpty(Queue* pq)
    96. {
    97. 	assert(pq);
    98.  
    99. 	return pq->phead == NULL;
    100. }
    101.  
    102. //获取队列中有效元素个数
    103. int QueueSize(Queue* pq)
    104. {
    105. 	assert(pq);
    106.  
    107. 	return pq->size;
    108. }

    test.c文件

    1. #include "Queue.h"
    2.  
    3. int main()
    4. {
    5. 	Queue q;
    6. 	QueueInit(&q);
    7. 	QueuePush(&q, 1);
    8. 	QueuePush(&q, 2);
    9. 	QueuePush(&q, 3);
    10. 	printf("%d ", QueueFront(&q));
    11. 	QueuePop(&q);
    12. 	printf("%d ", QueueFront(&q));
    13. 	QueuePop(&q);
    14.  
    15. 	QueuePush(&q, 4);
    16. 	QueuePush(&q, 5);
    17. 	while (!QueueEmpty(&q))
    18. 	{
    19. 		printf("%d ", QueueFront(&q));
    20. 		QueuePop(&q);
    21. 	}
    22.  
    23. 	QueueDestroy(&q);
    24.  
    25. 	return 0;
    26. }

    循环队列 

    概念：循环队列是一种特殊的队列数据结构，它通过使用固定大小的数组来实现。与普通队列不同的是，在循环队列中，当尾指针（rear）达到数组末尾时，会从数组开头重新开始存储元素

    优点：充分利用出队操作后释放出来的空间，避免频繁地移动元素

    适用场景：循环队列常用于需要高效处理连续输入输出流数据的场景，如缓冲区、任务调度等

    关于循环队列的实现放在下一篇文章......

    队列的OJ题

    用队列实现栈

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

    具体解题思路如下：

    1、题目要求使用两个队列，但队列的基本功能需要自己实现

    2、利用栈的结构体存储两个队列的头尾指针及队列元素个数的信息

    3、为队列申请结点空间并利用QueueInit函数初始化队列

    4、 入栈时，利用if判断谁为非空队列后，将要入栈的元素尾插进非空队列中(QueueBack函数)，出栈的大体过程如下图所示：

    5、出栈时，为了将队列的最后一个元素先排出，就需要让原来存储有效数据的队列的前N-1个元素放入空的队列中，然后再将元队列中的最后一个元素排出，两个队列的作用是来回切换的需要利用if语句判断队列的空与非空后在进行操作，出栈的大体过程如下图所示：

    6、获取栈顶元素时，只需要判断两个队列谁不为空，将不为空的队列的队尾元素返回即可

    7、判断栈是否为空时，当两个队列均为空时栈才能为空，所以需要用&&

    8、销毁栈时、不仅要释放掉malloc申请的内存空间，还要将两个队列一同销毁

    1. #include
    2. #include
    3. #include
    4. #include
    5.  
    6. //链式结构：表示队列
    7. typedef int QDataType;
    8. typedef struct QueueNode
    9. {
    10. 	QDataType val;
    11. 	struct QueueNode* next;
    12. }QNode;
    13.  
    14. //队列的结构（使用结构体避免了二级指针的使用）
    15. typedef struct Queue
    16. {
    17. 	QNode* phead;
    18. 	QNode* ptail;
    19. 	int size;
    20. }Queue;
    21.  
    22. //初始化队列
    23. void QueueInit(Queue* pq);
    24.  
    25. //队尾入队列
    26. void QueueDestroy(Queue* pq);
    27.  
    28. //队头出队列
    29. void QueuePush(Queue* pq, QDataType x);
    30.  
    31. //获取队头元素
    32. void QueuePop(Queue* pq);
    33.  
    34. //获取队尾元素
    35. QDataType QueueFront(Queue* pq);
    36.  
    37. //获取队列中有效元素个数
    38. QDataType QueueBack(Queue* pq);
    39.  
    40. //检测队列是否为空
    41. bool QueueEmpty(Queue* pq);
    42.  
    43. //销毁队列
    44. int QueueSize(Queue* pq);
    45.  
    46.  
    47.  
    48. //初始化队列
    49. void QueueInit(Queue* pq)
    50. {
    51. 	assert(pq);
    52. 	pq->phead = pq->ptail = NULL;
    53. 	pq->size = 0;
    54. }
    55.  
    56. //销毁队列
    57. void QueueDestroy(Queue* pq)
    58. {
    59. 	assert(pq);
    60.  
    61. 	QNode* cur = pq->phead;
    62. 	while (cur)
    63. 	{
    64. 		QNode* next = cur->next;
    65. 		free(cur);
    66. 		cur = next;
    67. 	}
    68.  
    69. 	pq->phead = pq->ptail = NULL;
    70. 	pq->size = 0;
    71. }
    72.  
    73. //队尾入队列
    74. void QueuePush(Queue* pq, QDataType x)
    75. {
    76. 	assert(pq);
    77.  
    78. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
    79. 	if (newnode == NULL)
    80. 	{
    81. 		perror("malloc fail");
    82. 		return;
    83. 	}
    84.  
    85. 	newnode->val = x;
    86. 	newnode->next = NULL;
    87.  
    88. 	if (pq->ptail == NULL)
    89. 	{
    90. 		pq->ptail = pq->phead = newnode;
    91. 	}
    92. 	else
    93. 	{
    94. 		pq->ptail->next = newnode;
    95. 		pq->ptail = newnode;
    96. 	}
    97.  
    98. 	pq->size++;
    99. }
    100.  
    101. // 对头出队列
    102. void QueuePop(Queue* pq)
    103. {
    104. 	assert(pq);
    105. 	// 
    106. 	assert(pq->phead);
    107.  
    108. 	QNode* del = pq->phead;
    109. 	pq->phead = pq->phead->next;
    110. 	free(del);
    111. 	del = NULL;
    112.  
    113. 	if (pq->phead == NULL)
    114. 		pq->ptail = NULL;
    115.  
    116. 	pq->size--;
    117. }
    118.  
    119. //获取队头元素
    120. QDataType QueueFront(Queue* pq)
    121. {
    122. 	assert(pq);
    123.  
    124. 	assert(pq->phead);
    125.  
    126. 	return pq->phead->val;
    127. }
    128.  
    129. //获取队尾元素
    130. QDataType QueueBack(Queue* pq)
    131. {
    132. 	assert(pq);
    133. 	 
    134. 	assert(pq->ptail);
    135.  
    136. 	return pq->ptail->val;
    137. }
    138.  
    139. //检测队列是否为空
    140. bool QueueEmpty(Queue* pq)
    141. {
    142. 	assert(pq);
    143.  
    144. 	return pq->phead == NULL;
    145. }
    146.  
    147. //获取队列中有效元素个数
    148. int QueueSize(Queue* pq)
    149. {
    150. 	assert(pq);
    151.  
    152. 	return pq->size;
    153. }
    154.  
    155. typedef struct {
    156.   Queue q1;
    157.   Queue q2;  
    158. } MyStack;
    159.  
    160. //初始化栈
    161. MyStack* myStackCreate() {
    162.     //申请结点空间
    163.     MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    164.     //取地址后就可以操作栈结构体中p1和p2中的内容
    165.     QueueInit(&pst->q1);       //->的优先级大于&
    166.     QueueInit(&pst->q2);       //->的优先级大于&
    167. 	return pst;
    168. }
    169.  
    170. //入栈
    171. void myStackPush(MyStack* obj, int x) {
    172.     //如果q1队列不为空则q1队列用于存放导出的数据
    173.     if(!QueueEmpty(&obj->q1))
    174.     {
    175.         QueuePush(&obj->q1,x);
    176.     }
    177.     //如果q1队列为空则q2队列用于存放导出的数据
    178.     else
    179.     {
    180.         QueuePush(&obj->q2,x);
    181.     }
    182. }
    183.  
    184. //出栈
    185. int myStackPop(MyStack* obj) {
    186.     //起始假设q1为空,q2不为空，empty指针指向空队列，noempty指向非空队列
    187.     Queue* empty = &obj->q1;
    188.     Queue* noempty = &obj->q2;
    189.     //如果我们假设失败则证明q1不为空，q2为空，交换标志
    190.     if(!QueueEmpty(&obj->q1))
    191.     {
    192.         empty = &obj->q2;
    193.         noempty = &obj->q1;
    194.     }
    195.     
    196.     //然后将队列中的前N-1个元素导入空队列，所以循环结束的条件就是队列中元素等于1(这个剩下的就是要出栈的元素)
    197.     while(QueueSize(noempty) > 1)
    198.     {
    199.         QueuePush(empty,QueueFront(noempty));
    200.         QueuePop(noempty);
    201.     }
    202.  
    203.     //将队列中前N-1个元素导出后剩余的就是要出栈的元素,将该元素存储进整型变量top中
    204.     int top = QueueFront(noempty);
    205.     //存储完成后将该元素也进行出队列操作
    206.     QueuePop(noempty);
    207.  
    208.     //最后返回要出栈的元素
    209.     return top;
    210. }
    211.  
    212. //获取栈顶元素
    213. int myStackTop(MyStack* obj) {
    214.     //谁不为空就获取谁的队尾元素
    215.     if(!QueueEmpty(&obj->q1))
    216.     {
    217.         return QueueBack(&obj->q1);
    218.     }
    219.     //如果q1队列为空则q2队列用于存放导出的数据
    220.     else
    221.     {
    222.         return QueueBack(&obj->q2);
    223.     }
    224. }
    225.  
    226. //判断栈是否为空
    227. bool myStackEmpty(MyStack* obj) {
    228.     //只有当两个队列均为空的时候，该栈才不会有有效数据
    229.     return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
    230. }
    231.  
    232. //销毁栈
    233. void myStackFree(MyStack* obj) {
    234.     //初始化时除了malloc了一个结点，还初始化了两个队列，所以除了要将申请的结点释放还要将申请的两个队列销毁
    235.     QueueDestroy(&obj->q1);
    236.     QueueDestroy(&obj->q2);
    237.  
    238.     free(obj);
    239. }

    关于&pst->q1的解释：

    为了操作队列，我们在初始化栈时需要将队列对象作为参数传递给函数，即&pst->q1，它表示获取指针 pst 所指向的结构体中成员变量 q1 的地址（可以理解为队列q1的地址），而pst是一个指向MyStack结构体的指针，所以说就是获取MyStack结构体中成员变量的地址。

    用栈实现队列

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

    具体解题思路如下：

    1、题目要求使用两个栈，但栈的基本功能需要自己实现

    2、利用栈的结构体存储两个队列的头尾指针及队列元素个数的信息

    3、为栈申请结点空间并利用STInit函数初始化栈

    4、入队时，直接利用STPush函数进行入栈即可

    5、先返回队头元素然后再出队，先判断用于出数据的popst栈是否为空，如果为空则将pushst栈中的数据倒顺序后放入popst栈中，利用STPush函数将pushst栈的栈顶元素放入空的popst栈中

    6、出队时，用临时变量front接收返回的队头元素，然后利用STPop函数将该元素出队，最后返回该元素的值

    7、判断队列是否为空时，当两个栈均为空时队列才能为空，所以需要用&&

    8、销毁栈时、不仅要释放掉malloc申请的内存空间，还要将两个栈一同销毁

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. //支持动态增长的栈
    6. typedef int STDataType;
    7. typedef struct Stack
    8. {
    9. 	STDataType* a;
    10. 	int top;	  //表示栈顶位置
    11. 	int capacity; //栈的容量
    12. }ST;
    13.  
    14. // 初始化栈
    15. void STInit(ST* ps);
    16.  
    17. // 销毁栈
    18. void STDestroy(ST* ps);
    19.  
    20. // 入栈
    21. void STPush(ST* ps, STDataType data);
    22.  
    23. // 出栈
    24. void STPop(ST* ps);
    25.  
    26. // 获取栈顶元素
    27. STDataType STTop(ST* ps);
    28.  
    29. // 获取栈中有效元素个数
    30. int STSize(ST* ps);
    31.  
    32. // 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
    33. int STEmpty(ST* ps);
    34.  
    35. // 初始化栈
    36. void STInit(ST* pst)
    37. {
    38.     //首先要指向一个栈
    39. 	assert(pst);
    40.  
    41. 	pst->a = NULL;
    42. 	pst->capacity = 0;
    43. 	pst->top = 0;    //令pop表示栈顶元素的下一个元素的下标
    44. }
    45.  
    46. // 销毁栈
    47. void STDestroy(ST* pst)
    48. {
    49.     //首先要指向一个栈
    50. 	assert(pst);
    51. 	
    52.     //正常操作不再过多复述
    53. 	free(pst->a);
    54. 	pst->a = NULL;
    55. 	pst->top = pst->capacity = 0;
    56. }
    57.  
    58. //入栈
    59. void STPush(ST* pst, STDataType x)
    60. {
    61.     //首先要指向一个栈
    62. 	assert(pst);
    63.     
    64.     //判断栈是否已满，如果栈满则申请新的内存空间
    65. 	if (pst->top == pst->capacity)
    66. 	{
    67. 		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
    68. 		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newCapacity);
    69. 		if (tmp == NULL)
    70. 		{
    71. 			perror("realloc fail");
    72. 			return;
    73. 		}
    74. 		pst->a = tmp;
    75. 		pst->capacity = newCapacity;
    76. 	}
    77.  
    78.     //如果栈未满则进行入栈操作（若初始化时pop=-1，则下面两行代码交换执行顺序）
    79. 	pst->a[pst->top] = x;    //此时pop表示的是栈顶元素的下一个元素的下标 
    80. 	pst->top++;              //top表示的下标数++
    81. }
    82.  
    83. //出栈
    84. void STPop(ST* pst)
    85. {
    86.     //首先要指向一个栈
    87. 	assert(pst);
    88. 	//top<0表示栈为空，top=0表示没有元素入栈，存在这两种情况就不能执行出栈操作（可以提供的图理解）
    89. 	assert(pst->top > 0);
    90.  
    91.     //直接对top执行减减操作以获取实际数组元素下标
    92.     pst->top--;
    93. }
    94.  
    95. // 获取栈顶元素
    96. STDataType STTop(ST* pst)
    97. {
    98.     //首先要指向一个栈
    99. 	assert(pst);
    100. 	//top<0表示栈为空，top=0表示没有元素入栈，存在这两种情况就不能执行出栈操作（可以提供的图理解）
    101. 	assert(pst->top > 0);
    102. 	
    103.     //当初始化top=0时，top的值与实际数组元素下标的值之间的关系是：实际下标 = top-1
    104.     //所以这里要进行减一操作得到实际的数组元素下标后再输出
    105. 	return pst->a[pst->top - 1];
    106. }
    107.  
    108. //获取栈中有效元素个数
    109. int STSize(ST* pst)
    110. {
    111.     //首先要指向一个栈
    112. 	assert(pst);
    113.     
    114.     //初始化top=0，则top等于多少栈中就有多少个元素
    115. 	return pst->top;
    116. }
    117.  
    118. //检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
    119. int STEmpty(ST* pst)
    120. {
    121. 	//首先要指向一个栈
    122. 	assert(pst);
    123. 	
    124.     //如果pst->top不为空则返回结果为真，为空则返回假
    125. 	return pst->top == NULL;
    126. }
    127.  
    128. typedef struct {
    129.     ST pushst;
    130.     ST popst;    
    131. } MyQueue;
    132.  
    133. //初始化栈
    134. MyQueue* myQueueCreate() {
    135.     MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    136.     STInit(&obj->pushst);
    137.     STInit(&obj->popst);
    138.     return obj;
    139. }
    140.  
    141. //入队
    142. void myQueuePush(MyQueue* obj, int x) {
    143.         STPush(&obj->pushst,x);
    144. }
    145.  
    146. //出队
    147. int myQueuePop(MyQueue* obj) {
    148.     int front = myQueuePeek(obj);
    149.     STPop(&obj->popst);
    150.     return front;
    151. }
    152.  
    153. //返回队头元素
    154. int myQueuePeek(MyQueue* obj) {
    155.     //栈不为空就倒数据
    156.     if(STEmpty(&obj->popst))
    157.     {
    158.         //将pusust里面的数据倒转顺序后传递给popst
    159.         while(!STEmpty(&obj->pushst))
    160.         {
    161.             STPush(&obj->popst, STTop(&obj->pushst));
    162.             STPop(&obj->pushst);
    163.         }
    164.     }
    165.  
    166.     return STTop(&obj->popst);
    167. }
    168.  
    169. //判断是否为空
    170. bool myQueueEmpty(MyQueue* obj) {
    171.     return STEmpty(&obj->popst) && STEmpty(&obj->pushst);
    172. }
    173.  
    174. //销毁队
    175. void myQueueFree(MyQueue* obj) {
    176.     STDestroy(&obj->popst);
    177.     STDestroy(&obj->pushst);
    178. }
    179.  
    180. /**
    181.  * Your MyQueue struct will be instantiated and called as such:
    182.  * MyQueue* obj = myQueueCreate();
    183.  * myQueuePush(obj, x);
    184.  
    185.  * int param_2 = myQueuePop(obj);
    186.  
    187.  * int param_3 = myQueuePeek(obj);
    188.  
    189.  * bool param_4 = myQueueEmpty(obj);
    190.  
    191.  * myQueueFree(obj);
    192. */

    关于&pst->pushst和&pst->popst的解释：

    ~over~ 

  • 相关阅读:
    海思3559开发常识储备：相关名词全解
    Grafana dashboards as ConfigMaps
    Linux Vim 进阶教程
    记一次hook mac地址实现伪装硬件码
    开放式耳机怎么选，最适合佩戴的几款耳机推荐
    华为机试真题实战应用【赛题代码篇】-打印任务排序（附Java、Python和C++代码）
    bloaty
    javascript 使用vue实现全选和取消全选
    STM32:GPIO控制LED流水灯(主函数代码部分+代码解释)
    vue项目中引入Luckysheet
  • 原文地址：https://blog.csdn.net/m0_73975164/article/details/134483604