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

栈和队列&循环队列（C/C++）

作者：不正经 | 2024-02-17 23:00:12

赞

踩

栈和队列&循环队列（C/C++）

        本篇将用数组实现栈、链表实现队列以及使用数组实现循环队列，然后实现了用栈实现队列和用队列实现栈以及一些其他的栈和队列的习题，加深队栈和队列的理解。

        若只看对应所需，可直接看文章旁的目录。

1.栈

1.1栈的概念及结构

        栈：一种特殊的线性表，其中只允许在固定的一端插入和删除元素，进行数据插入和删除操作的一端被称为栈顶，另一端被称为栈底。栈中的数据元素遵守先进后出LIFO（Last In First Out）的原则。

        压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

        出栈：栈的删除操作叫做出栈，出数据也在栈顶。

        上图就是出栈和压栈的示意图。 

1.2栈的实现

        栈的实现一般可以使用数据或者链表实现，但相对而言使用数组实现更优一些，因为数组在尾上插入数据的代价比较小。

        所以本篇将使用数组实现栈。

        注：对于数组实现栈，我们可以将栈顶指针指向栈顶元素，也可以指向栈顶元素的上一个位置，这两种实现方式都是可以的。本篇的栈顶指针指向的是栈的上一个元素。两种的实现方式都有略微的不同。

        对于栈的实现，对于较难理解的将给出注释，如下：

1.2.1 Stack.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdbool.h>
  5. #include <assert.h>
  6.  
  7. //定义元素数据类型
  8. typedef int STDataType;
  9.  
  10. //栈的数据结构
  11. typedef struct Stack {
  12. 	STDataType* arr;
  13. 	int top;
  14. 	int capacity;
  15. }Stack;
  16.  
  17. //栈的初始化以及销毁
  18. void STInit(Stack* ps);
  19. void STDestroy(Stack* ps);
  20.  
  21. //压栈与出栈
  22. void STPush(Stack* ps, STDataType x);
  23. void STPop(Stack* ps);
  24.  
  25. //返回栈顶元素/栈的尺寸/栈是否为NULL
  26. STDataType STTop(Stack* ps);
  27. int STSize(Stack* ps);
  28. bool STEmpty(Stack* ps);

1.2.2 Stack.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "Stack.h"
  3.  
  4. void STInit(Stack* ps) {
  5. 	assert(ps);
  6. 	ps->arr = NULL;
  7. 	ps->capacity = 0;
  8. 	ps->top = 0;
  9. }
  10.  
  11. void STDestroy(Stack* ps) {
  12. 	assert(ps);
  13. 	free(ps->arr);
  14. 	ps->arr = NULL;
  15. 	ps->capacity = 0;
  16. 	ps->top = 0;
  17. 	ps = NULL;
  18. }
  19.  
  20. void STPush(Stack* ps, STDataType x) {
  21. 	assert(ps);
  22. 	//判断栈是否需要扩容
  23. 	if (STSize(ps) == ps->capacity) {
  24. 		//三目操作符进行扩容，第一次的容量为4，以后每次扩容一倍
  25. 		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
  26. 		STDataType* tmp = (STDataType*)realloc(ps->arr, newcapacity * sizeof(STDataType));
  27. 		if (tmp == NULL) {
  28. 			perror("realloc:");
  29. 			exit(1);
  30. 		}
  31. 		ps->arr = tmp;
  32. 		ps->capacity = newcapacity;
  33. 	}
  34. 	ps->arr[ps->top] = x;
  35. 	ps->top++;
  36. }
  37.  
  38. void STPop(Stack* ps) {
  39. 	assert(ps);
  40. 	assert(!STEmpty(ps));
  41. 	//出栈只需要将栈的尺寸减小，下次压栈的元素直接进行覆盖
  42. 	ps->top--;
  43. }
  44.  
  45. STDataType STTop(Stack* ps) {
  46. 	assert(ps);
  47. 	assert(!STEmpty(ps));
  48. 	STDataType ret = ps->arr[ps->top - 1];
  49. 	return ret;
  50. }
  51.  
  52. int STSize(Stack* ps) {
  53. 	assert(ps);
  54. 	//栈顶的编号其实就是栈的尺寸
  55. 	return ps->top;
  56. }
  57.  
  58. bool STEmpty(Stack* ps) {
  59. 	assert(ps);
  60. 	return ps->top == 0;
  61. }

1.2.3 All of Code

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdbool.h>
  5. #include <assert.h>
  6.  
  7. //定义元素数据类型
  8. typedef int STDataType;
  9.  
  10. //栈的数据结构
  11. typedef struct Stack {
  12. 	STDataType* arr;
  13. 	int top;
  14. 	int capacity;
  15. }Stack;
  16.  
  17. //栈的初始化以及销毁
  18. void STInit(Stack* ps);
  19. void STDestroy(Stack* ps);
  20.  
  21. //压栈与出栈
  22. void STPush(Stack* ps, STDataType x);
  23. void STPop(Stack* ps);
  24.  
  25. //返回栈顶元素/栈的尺寸/栈是否为NULL
  26. STDataType STTop(Stack* ps);
  27. int STSize(Stack* ps);
  28. bool STEmpty(Stack* ps);
  29.  
  30. void STInit(Stack* ps) {
  31. 	assert(ps);
  32. 	ps->arr = NULL;
  33. 	ps->capacity = 0;
  34. 	ps->top = 0;
  35. }
  36.  
  37. void STDestroy(Stack* ps) {
  38. 	assert(ps);
  39. 	free(ps->arr);
  40. 	ps->arr = NULL;
  41. 	ps->capacity = 0;
  42. 	ps->top = 0;
  43. 	ps = NULL;
  44. }
  45.  
  46. void STPush(Stack* ps, STDataType x) {
  47. 	assert(ps);
  48. 	//判断栈是否需要扩容
  49. 	if (STSize(ps) == ps->capacity) {
  50. 		//三目操作符进行扩容，第一次的容量为4，以后每次扩容一倍
  51. 		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
  52. 		STDataType* tmp = (STDataType*)realloc(ps->arr, newcapacity * sizeof(STDataType));
  53. 		if (tmp == NULL) {
  54. 			perror("realloc:");
  55. 			exit(1);
  56. 		}
  57. 		ps->arr = tmp;
  58. 		ps->capacity = newcapacity;
  59. 	}
  60. 	ps->arr[ps->top] = x;
  61. 	ps->top++;
  62. }
  63.  
  64. void STPop(Stack* ps) {
  65. 	assert(ps);
  66. 	assert(!STEmpty(ps));
  67. 	//出栈只需要将栈的尺寸减小，下次压栈的元素直接进行覆盖
  68. 	ps->top--;
  69. }
  70.  
  71. STDataType STTop(Stack* ps) {
  72. 	assert(ps);
  73. 	assert(!STEmpty(ps));
  74. 	STDataType ret = ps->arr[ps->top - 1];
  75. 	return ret;
  76. }
  77.  
  78. int STSize(Stack* ps) {
  79. 	assert(ps);
  80. 	//栈顶的编号其实就是栈的尺寸
  81. 	return ps->top;
  82. }
  83.  
  84. bool STEmpty(Stack* ps) {
  85. 	assert(ps);
  86. 	return ps->top == 0;
  87. }
  88.  
  89. int main() {
  90. 	Stack st;
  91. 	STInit(&st);
  92. 	STPush(&st, 1);
  93. 	STPush(&st, 2);
  94. 	STPush(&st, 3);
  95. 	while (!STEmpty(&st)) {
  96. 		STDataType top = STTop(&st);
  97. 		STPop(&st);
  98. 		printf("%d ", top);
  99. 	}
  100. 	STPush(&st, 4);
  101. 	STPush(&st, 5);
  102. 	while (!STEmpty(&st)) {
  103. 		STDataType top = STTop(&st);
  104. 		STPop(&st);
  105. 		printf("%d ", top);
  106. 	}
  107. 	STDestroy(&st);
  108. 	return 0;
  109. }

        测试结果： 

2.队列

2.1 队列的概念及结构

        队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First In First Out）的性质。

        入队列：进行插入操作的一端称为队尾。

        出队列：进行删除操作的一端称为队头。 

2.2队列的实现 

        对于队列的实现，都可以使用数组以及链表结构，但是使用链表结构实现出队以及入队将更方便，同时还会节省更多的空间。

        如上图所示，当使用数组实现队列时，由于开辟的空间是固定的，所以出队时将会浪费一些空间。 

2.2.1 Queue.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6.  
  7. typedef int QDataType;
  8.  
  9. //队列节点的数据结构
  10. typedef struct Node {
  11. 	QDataType val;
  12. 	struct Node* next;
  13. }QNode;
  14.  
  15. //队列的队首指针、队尾指针、尺寸
  16. typedef struct Queue {
  17. 	int size;
  18. 	QNode* phead;
  19. 	QNode* ptail;
  20. }Queue;
  21.  
  22. //队列的初始化/销毁
  23. void QueueInit(Queue* pQ);
  24. void QueueDestory(Queue* pQ);
  25.  
  26. //队列的入队/出队
  27. void QueuePush(Queue* pQ, QDataType x);
  28. void QueuePop(Queue* pQ);
  29.  
  30. //返回队首元素/队尾元素
  31. QDataType QueueFront(Queue* pQ);
  32. QDataType QueueBack(Queue* pQ);
  33.  
  34. //判断队列是否为NULL/返回队列的大小
  35. bool QueueEmpty(Queue* pQ);
  36. int QueueSize(Queue* pQ);
  37.

2.2.2 Queue.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "Queue.h"
  3.  
  4. void QueueInit(Queue* pQ) {
  5. 	assert(pQ);
  6. 	pQ->phead = pQ->ptail = NULL;
  7. 	pQ->size = 0;
  8. }
  9.  
  10. void QueueDestory(Queue* pQ) {
  11. 	assert(pQ);
  12. 	QNode* cur = pQ->phead;
  13. 	while (cur) {
  14. 		QNode* next = cur->next;
  15. 		free(cur);
  16. 		cur = next;
  17. 	}
  18. 	pQ->phead = pQ->ptail = NULL;
  19. 	pQ->size = 0;
  20. }
  21.  
  22. void QueuePush(Queue* pQ, QDataType x) {
  23. 	assert(pQ);
  24. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
  25. 	if (newnode == NULL) {
  26. 		perror("malloc:");
  27. 		exit(1);
  28. 	}
  29. 	newnode->val = x;
  30. 	newnode->next = NULL;
  31. 	if (pQ->phead == NULL) {
  32. 		pQ->phead = pQ->ptail = newnode;
  33. 	}
  34. 	else {
  35. 		pQ->ptail->next = newnode;
  36. 		pQ->ptail = newnode;
  37. 	}
  38. 	pQ->size++;
  39. }
  40.  
  41. void QueuePop(Queue* pQ) {
  42. 	assert(pQ);
  43. 	assert(pQ->phead);
  44. 	QNode* cur = pQ->phead;
  45. 	pQ->phead = pQ->phead->next;
  46. 	free(cur);
  47. 	cur = NULL;
  48. 	pQ->size--;
  49. }
  50.  
  51. QDataType QueueFront(Queue* pQ) {
  52. 	assert(pQ);
  53. 	assert(pQ->phead);
  54. 	return pQ->phead->val;
  55. }
  56.  
  57. QDataType QueueBack(Queue* pQ) {
  58. 	assert(pQ);
  59. 	assert(pQ->phead);
  60. 	return pQ->ptail->val;
  61. }
  62.  
  63. bool QueueEmpty(Queue* pQ) {
  64. 	assert(pQ);
  65. 	return pQ->phead == NULL;
  66. }
  67.  
  68. int QueueSize(Queue* pQ) {
  69. 	assert(pQ);
  70. 	return pQ->size;
  71. }

2.2.3 All of Code

 

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6.  
  7. typedef int QDataType;
  8.  
  9. //队列节点的数据结构
  10. typedef struct Node {
  11. 	QDataType val;
  12. 	struct Node* next;
  13. }QNode;
  14.  
  15. //队列的队首指针、队尾指针、尺寸
  16. typedef struct Queue {
  17. 	int size;
  18. 	QNode* phead;
  19. 	QNode* ptail;
  20. }Queue;
  21.  
  22. //队列的初始化/销毁
  23. void QueueInit(Queue* pQ);
  24. void QueueDestory(Queue* pQ);
  25.  
  26. //队列的入队/出队
  27. void QueuePush(Queue* pQ, QDataType x);
  28. void QueuePop(Queue* pQ);
  29.  
  30. //返回队首元素/队尾元素
  31. QDataType QueueFront(Queue* pQ);
  32. QDataType QueueBack(Queue* pQ);
  33.  
  34. //判断队列是否为NULL/返回队列的大小
  35. bool QueueEmpty(Queue* pQ);
  36. int QueueSize(Queue* pQ);
  37.  
  38. void QueueInit(Queue* pQ) {
  39. 	assert(pQ);
  40. 	pQ->phead = pQ->ptail = NULL;
  41. 	pQ->size = 0;
  42. }
  43.  
  44. void QueueDestory(Queue* pQ) {
  45. 	assert(pQ);
  46. 	QNode* cur = pQ->phead;
  47. 	while (cur) {
  48. 		QNode* next = cur->next;
  49. 		free(cur);
  50. 		cur = next;
  51. 	}
  52. 	pQ->phead = pQ->ptail = NULL;
  53. 	pQ->size = 0;
  54. }
  55.  
  56. void QueuePush(Queue* pQ, QDataType x) {
  57. 	assert(pQ);
  58. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
  59. 	if (newnode == NULL) {
  60. 		perror("malloc:");
  61. 		exit(1);
  62. 	}
  63. 	newnode->val = x;
  64. 	newnode->next = NULL;
  65. 	if (pQ->phead == NULL) {
  66. 		pQ->phead = pQ->ptail = newnode;
  67. 	}
  68. 	else {
  69. 		pQ->ptail->next = newnode;
  70. 		pQ->ptail = newnode;
  71. 	}
  72. 	pQ->size++;
  73. }
  74.  
  75. void QueuePop(Queue* pQ) {
  76. 	assert(pQ);
  77. 	assert(pQ->phead);
  78. 	QNode* cur = pQ->phead;
  79. 	pQ->phead = pQ->phead->next;
  80. 	free(cur);
  81. 	cur = NULL;
  82. 	pQ->size--;
  83. }
  84.  
  85. QDataType QueueFront(Queue* pQ) {
  86. 	assert(pQ);
  87. 	assert(pQ->phead);
  88. 	return pQ->phead->val;
  89. }
  90.  
  91. QDataType QueueBack(Queue* pQ) {
  92. 	assert(pQ);
  93. 	assert(pQ->phead);
  94. 	return pQ->ptail->val;
  95. }
  96.  
  97. bool QueueEmpty(Queue* pQ) {
  98. 	assert(pQ);
  99. 	return pQ->phead == NULL;
  100. }
  101.  
  102. int QueueSize(Queue* pQ) {
  103. 	assert(pQ);
  104. 	return pQ->size;
  105. }
  106.  
  107. int main() {
  108. 	Queue queue;
  109. 	QueueInit(&queue);
  110. 	QueuePush(&queue, 1);
  111. 	QueuePush(&queue, 2);
  112. 	printf("%d ", QueueFront(&queue));
  113. 	QueuePop(&queue);
  114. 	QueuePush(&queue, 3);
  115. 	QueuePush(&queue, 4);
  116. 	printf("%d ", QueueFront(&queue));
  117. 	QueuePop(&queue);
  118. 	QueuePush(&queue, 5);
  119. 	while (!QueueEmpty(&queue)) {
  120. 		printf("%d ", QueueFront(&queue));
  121. 		QueuePop(&queue);
  122. 	}
  123. 	QueueDestory(&queue);
  124. 	return 0;
  125. }

        测试结果：

2.3循环队列的实现 

        在上文中我们提到，当我们使用数组实现队列的时候，会出现一些空间浪费的情况，这是因为出队时，出队下标将向后移动，前面的空间则浪费，当我们使用循环链表就可以很好的解决该问题。

        循环链表：将数组的首尾相连，组成的一个特殊结构。我们用两个指针来表示队列的队首和队尾，front 表示队首，back表示队尾的下一个元素。

        为了能使Q.front=Q.back来区别队列是否为空还是满，我们常常认为出现作图时的情况即为队满的情况，此时：Q.front=Q.back+1;

        对于循环队列的代码实现如下，对于代码的解释在注释给出。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. typedef struct {
  6.     int* arr;
  7.     int front;
  8.     int back;
  9.     int k;
  10. } MyCircularQueue;
  11.  
  12. //循环队列的初始化
  13. MyCircularQueue* myCircularQueueCreate(int k) {
  14.     //堆上分配空间，才能在出函数时仍然存在
  15.     MyCircularQueue* Queue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
  16.     if(Queue==NULL){
  17.         perror("malloc:");
  18.         exit(1);
  19.     }
  20.     //分配k+1个空间，便于我们判断是否为满队列还是空队列
  21.     Queue->arr=(int*)malloc(sizeof(int)*(k+1));
  22.     Queue->front=Queue->back=0;
  23.     Queue->k=k;
  24.     return Queue;
  25. }
  26.  
  27. //判断队列是否为NULL队列
  28. bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
  29.     return obj->front==obj->back;
  30. }
  31.  
  32. //判断队列是否为满队列
  33. bool myCircularQueueIsFull(MyCircularQueue* obj) {
  34.     return obj->front==(obj->back+1)%(obj->k+1);
  35. }
  36.  
  37. //在队列中加入元素
  38. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
  39.     if(myCircularQueueIsFull(obj)){
  40.         return false;
  41.     }
  42.     else{
  43.         obj->arr[obj->back]=value;
  44.         obj->back++;
  45.         obj->back%=(obj->k+1);
  46.         return true;
  47.     }
  48. }
  49.  
  50. //队列中删除元素
  51. bool myCircularQueueDeQueue(MyCircularQueue* obj) {
  52.     if(myCircularQueueIsEmpty(obj)){
  53.         return false;
  54.     }
  55.     else{
  56.         obj->front++;
  57.         obj->front%=(obj->k+1);
  58.         return true;
  59.     }
  60. }
  61.  
  62. //返回队首元素
  63. int myCircularQueueFront(MyCircularQueue* obj) {
  64.     if(myCircularQueueIsEmpty(obj)){
  65.         return -1;
  66.     }
  67.     return obj->arr[obj->front];
  68. }
  69.  
  70. //返回队尾元素
  71. int myCircularQueueRear(MyCircularQueue* obj) {
  72.     if(myCircularQueueIsEmpty(obj)){
  73.         return -1;
  74.     }
  75.     //对于队尾元素的返回，需要注意是否为队列中第k+1个元素，有以下两种写法
  76.     //return obj->arr[(obj->back+obj->k)%(obj->k+1)];
  77.     if(obj->back==0){
  78.         return obj->arr[obj->k];
  79.     }else{
  80.         return obj->arr[obj->back-1];
  81.     }
  82. }
  83.  
  84. //释放空间
  85. void myCircularQueueFree(MyCircularQueue* obj) {
  86.     free(obj->arr);
  87.     free(obj);
  88. }

        对于以上循环队列的实现，其实是一个习题，链接如下：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/design-circular-queue/description/         测试结果：

3.栈与队列相关习题

        注：在习题中使用的函数都是以上的代码函数。

3.1队列实现栈

        使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 

        习题链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/implement-stack-using-queues        若要使用两个队列实现栈的操作，最难的两个操作及就是出栈和压栈。

        对于压栈，我们只需将要压栈的元素压入一个非空队列，另一个队列保存空。

        对于出栈，我们只需要除最后一个元素的队列进入另一个空队列，然后在删除最后一个元素及就实现了出栈。代码如下：

  1. typedef struct {
  2.     Queue p1;
  3.     Queue p2;
  4. } MyStack;
  5.  
  6.  
  7. MyStack* myStackCreate() {
  8.     MyStack* stack=(MyStack*)malloc(sizeof(MyStack));
  9.     if(stack==NULL){
  10.         perror("stack's malloc:");
  11.         exit(1);
  12.     }
  13.     QueueInit(&stack->p2);
  14.     QueueInit(&stack->p1);
  15.     return stack;
  16. }
  17.  
  18. void myStackPush(MyStack* obj, int x) {
  19.     if(!QueueEmpty(&obj->p1))
  20.         QueuePush(&obj->p1,x);
  21.     else
  22.         QueuePush(&obj->p2,x);
  23. }
  24.  
  25. int myStackPop(MyStack* obj) {
  26.     Queue* empty=&obj->p1;
  27.     Queue* nonempty=&obj->p2;
  28.     if(!QueueEmpty(empty)){
  29.         empty=&obj->p2;
  30.         nonempty=&obj->p1;
  31.     } 
  32.     while(QueueSize(nonempty)>1){
  33.         QueuePush(empty,QueueFront(nonempty));
  34.         QueuePop(nonempty);
  35.     }
  36.     int top=QueueFront(nonempty);
  37.     QueuePop(nonempty);
  38.     return top;
  39. }
  40.  
  41. int myStackTop(MyStack* obj) {
  42.     if(!QueueEmpty(&obj->p1)){
  43.         return QueueBack(&obj->p1);
  44.     }else{
  45.         return QueueBack(&obj->p2);
  46.     }
  47. }
  48.  
  49. bool myStackEmpty(MyStack* obj) {
  50.     return QueueEmpty(&obj->p1)&&QueueEmpty(&obj->p2);
  51. }
  52.  
  53. void myStackFree(MyStack* obj) {
  54.     QueueDestory(&obj->p1);
  55.     QueueDestory(&obj->p2);
  56.     free(obj);
  57.     obj=NULL;
  58. }

        测试结果：

3.2栈实现队列 

        使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

        习题链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/implement-queue-using-stacks/         使用两个栈实现队列,主要思想为：一组数据进栈两次即可实现先进先出。

        一个栈作为入队栈，只用来将数据压入栈；

        另一个栈作为出队栈，只用来将数据弹出栈；

        当我们需要将数据出队时，我们将入队栈的数据全部压入出队栈，此时出栈的顺序正确，注意：这里只有当出队栈为空时才能将入队栈的数据压入出队栈，要不然会导致出队的顺序错乱。

  1. typedef struct {
  2.     Stack pushst;
  3.     Stack popst;
  4. } MyQueue;
  5.  
  6. MyQueue* myQueueCreate() {
  7.     MyQueue* Queue=(MyQueue*)malloc(sizeof(MyQueue));
  8.     if(Queue==NULL){
  9.         perror("queue malloc:");
  10.         exit(1);
  11.     }
  12.     STInit(&Queue->pushst);
  13.     STInit(&Queue->popst);
  14.     return Queue;
  15. }
  16.  
  17. void myQueuePush(MyQueue* obj, int x) {
  18.     //将元素压入push栈
  19.     STPush(&obj->pushst,x);
  20. }
  21.  
  22. int myQueuePeek(MyQueue* obj) {
  23.     if(STEmpty(&obj->popst)){
  24.         while(!STEmpty(&obj->pushst)){
  25.             STPush(&obj->popst,STTop(&obj->pushst));
  26.             STPop(&obj->pushst);
  27.         }
  28.     }
  29.     int front=STTop(&obj->popst);
  30.     return front;
  31. }
  32.  
  33. int myQueuePop(MyQueue* obj) {
  34.     int front=myQueuePeek(obj);
  35.     STPop(&obj->popst);
  36.     return front;
  37. }
  38.  
  39. bool myQueueEmpty(MyQueue* obj) {
  40.     return STEmpty(&obj->popst)&&STEmpty(&obj->pushst);
  41. }
  42.  
  43. void myQueueFree(MyQueue* obj) {
  44.     STDestroy(&obj->popst);
  45.     STDestroy(&obj->pushst);
  46.     free(obj);
  47.     obj=NULL;
  48. }

        测试结果： 

3.3有效的括号匹配

        给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

        习题链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/valid-parentheses/description/         对于该题的实现，主要思想是将所有的左括号压入栈，只要遇到右括号，将栈的中左括号弹出，判断是否配对，若不配对则返回ERROR，一直配对和判断，若最后栈为NULL，说明完全配对，则我们可以判断括号匹配。代码如下：

  1. bool isValid(char* s) {
  2.     Stack st;
  3.     STInit(&st);
  4.     while(*s){
  5.         if(*s=='['||*s=='('||*s=='{'){
  6.             STPush(&st,*s);
  7.         }else{
  8.             if(STEmpty(&st)){
  9.                 STDestroy(&st);
  10.                 return false;
  11.             }
  12.             char ch=STTop(&st);
  13.             STPop(&st);
  14.             if((ch=='('&&*s!=')')||(ch=='{'&&*s!='}')||(ch=='['&&*s!=']')){
  15.                 return false;
  16.             }
  17.         }
  18.         s++;
  19.     }
  20.     bool ret=STEmpty(&st);
  21.     STDestroy(&st);
  22.     return ret;
  23. }

        测试结果：

 

 

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

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

  

闽ICP备14008679号