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

数据结构：栈和队列的实现附上源代码（C语言版）_栈和队列的存储结构的实现 参考代码devc

作者：小蓝xlanll | 2024-05-07 23:58:56

赞

踩

栈和队列的存储结构的实现 参考代码devc

目录

前言

1.栈

1.1 栈的概念及结构

1.2 栈的底层数据结构选择

1.2 数据结构设计代码（栈的实现）

1.3 接口函数实现代码

（1）初始化栈

（2）销毁栈

（3）压栈

（4）出栈

（5）获取栈顶元素

（6）获取栈中有效元素的个数

（7）检测栈是否为空

1.4 测试函数

2. 队列

2.1 队列概念及结构

2.2 队列的底层数据结构的选择

2.2 数据结构设计代码（队列的实现）

2.3 接口函数

（1）初始化队列

（2）销毁队列

（3）队尾入队列

（4）队头出队列

（5）获取队列头部元素

（6）获取队列尾部元素

（7）获取队列中有效元素个数

（8）检测队列是否为空

2.4 测试函数

3. 栈和队列的源代码

3.1 栈

（1）Stack.h

（2）Stack.c

（3）STtest.c

3.2 队列

（1）Queue.h

（2）Queue.c

（3）Qtest.c

总结

前言

这篇文章是关于栈和队列的C语言实现，干货满满，大家可以边看边手写代码，最后附上栈和队列的参考代码。

1.栈

1.1 栈的概念及结构

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

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

这个数据结构可以理解为炸串。在最开始，插入丸子时，要插到这根签的最底部，就是入栈。开始吃的时候，一般从最上面的丸子入手，就是出栈。

1.2 栈的底层数据结构选择

我们学过顺序表和链表两种数据结构，用那种会更好呢？

  • 相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。不用挪动数据，删除操作也很简单。
  • 而链表如果要入栈，就是链表的尾插，我们需要找到链表的尾结点，效率低。出栈也是一样。

1.2 数据结构设计代码（栈的实现）

在用C语言实现栈各种接口函数，需要创建三个文件，分别是STtest.c，Stack.c和Stack.h。

  • STtest.c文件用来测试接口函数是否能成功。
  • Stack.c文件里面放的是各种接口函数实现的代码
  • Stack.h文件放置各种头文件的声明，栈数据结构的设计和接口函数的声明。下面的代码就是放在此文件中。
  1. typedef int STDataType;
  2. // 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
  3. typedef int STDataType;
  4. #define N 10
  5. typedef struct Stack
  6. {
  7. 	STDataType _a[N];
  8. 	int _top; // 栈顶
  9. }Stack;
  10.  
  11. // 支持动态增长的栈
  12. typedef struct Stack
  13. {
  14. 	STDataType* a;
  15. 	int top;      //栈顶
  16. 	int capacity; //容量
  17. }ST;
  18.  
  19. //初始化栈
  20. void StackInit(ST* ps);
  21. //销毁栈
  22. void StackDestroy(ST* ps);
  23. //压栈
  24. void StackPush(ST* ps, STDataType x);
  25. //出栈
  26. void StackPop(ST* ps);
  27. //获取栈顶元素
  28. STDataType StackTop(ST* ps);
  29. //获取栈中有效元素个数
  30. int StackSize(ST* ps);
  31. //检测栈是否为空，为空返回true
  32. bool StackEmpty(ST* ps);

1.3 接口函数实现代码

（1）初始化栈

初始化栈一开始要断言，断言来判断ps指针是否为空，如果为空会直接终止程序并给出提示，方便之后的调试，之后的断言不再赘述。指针指向空，内部整型数据赋值为0。但是top得注意，top其实也是个下标。看下面的注释，top可以有两种赋值方式，只是表示不同意思。

  1. void StackInit(ST* ps)
  2. {
  3. 	assert(ps);
  4. 	ps->a = NULL;
  5. 	ps->top = 0;//表示指向栈顶的下一个元素
  6.     //ps->top = -1 ///表示指向栈顶元素
  7. 	ps->capacity = 0;
  8. }

（2）销毁栈

因为我们是以数组为基础，是动态开辟的连续空间，直接释放掉ps中的数组指针，并要置为空。

  1. void StackDestroy(ST* ps)
  2. {
  3. 	assert(ps);
  4. 	free(ps->a);
  5. 	ps->a = NULL;//易错
  6. 	ps->top = ps->capacity = 0;
  7. }

（3）压栈

栈的压栈操作跟顺序表的尾插类似，先要检查内部空间容量是否足够，一开始给四个该数据结构的空间，之后的按两倍来扩容。最后就是插入数据，栈顶减一。

  1. void StackPush(ST* ps, STDataType x)
  2. {
  3. 	assert(ps);
  4.  
  5. 	if (ps->top == ps->capacity)
  6. 	{
  7. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  8. 		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
  9. 		if (tmp == NULL)
  10. 		{
  11. 			printf("realloc fail\n");
  12. 			exit(-1);
  13. 		}
  14.  
  15. 		ps->a = tmp;
  16. 		ps->capacity = newCapacity;
  17. 	}
  18.  
  19. 	ps->a[ps->top] = x;
  20. 	ps->top++;
  21. }

（4）出栈

这次不仅要判断ps是否不为空指针，还要判断栈内是否有元素，这样才可以删除元素，让栈顶减一即可。

  1. void StackPop(ST* ps)
  2. {
  3. 	assert(ps);
  4. 	assert(!StackEmpty(ps));
  5.  
  6. 	ps->top--;
  7. }

（5）获取栈顶元素

这里的判断跟上个接口函数一样，只有栈内有元素，才能取栈顶元素。

  1. STDataType StackTop(ST* ps)
  2. {
  3. 	assert(ps);
  4. 	assert(!StackEmpty(ps));
  5.  
  6. 	return ps->a[ps->top - 1];
  7. }

（6）获取栈中有效元素的个数

此时的top表示的是栈顶的下一个元素的下标，刚好就是元素个数，直接返回栈顶top

  1. int StackSize(ST* ps)
  2. {
  3. 	assert(ps);
  4.  
  5. 	return ps->top;
  6. }

（7）检测栈是否为空

很多人会写个if语句判断，其实可以直接像下面一样写，ps->top == 0变成一个判断语句，如果为真返回一个部位0的数，如果为假返回0。

  1. bool StackEmpty(ST* ps)
  2. {
  3. 	assert(ps);
  4.  
  5. 	return ps->top == 0;
  6. }

1.4 测试函数

我们写两个测试函数，第一个测试函数，是出栈和入栈的操作，可以调试查看。第二个测试函数是栈的数据打印，需要使用StackTop获取栈顶元素，然后将打印的数据出栈。

  1. void TestStack1()
  2. {
  3. 	ST st;
  4. 	StackInit(&st);
  5.  
  6. 	StackPush(&st, 1);
  7. 	StackPush(&st, 2);
  8. 	StackPush(&st, 3);
  9. 	StackPush(&st, 4);
  10.  
  11. 	StackPop(&st);
  12. 	StackPop(&st);
  13. 	StackPop(&st);
  14. 	StackPop(&st);
  15. 	StackPop(&st);
  16.  
  17. 	StackDestroy(&st);
  18. }
  19.  
  20. void TestStack2()
  21. {
  22. 	ST st;
  23. 	StackInit(&st);
  24.  
  25. 	StackPush(&st, 1);
  26. 	StackPush(&st, 2);
  27. 	StackPush(&st, 3);
  28. 	StackPush(&st, 4);
  29.  
  30. 	while (!StackEmpty(&st))
  31. 	{
  32. 		printf("%d ", StackTop(&st));
  33. 		StackPop(&st);
  34. 	}
  35. 	StackDestroy(&st);
  36. }
  37.  
  38. int main()
  39. {
  40. 	TestStack1();
  41. 	TestStack2();
  42.  
  43. 	return 0;
  44. }

输出结果：

2. 队列

2.1 队列概念及结构

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

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

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

 这个数据结构可以理解为在银行取号，先取号的人，就是入队列。然后先取到号的人，就先去窗口处理业务，这就是出队列。

2.2 队列的底层数据结构的选择

跟栈一样，队列也可以用顺序表和链表来实现，那哪一个更好呢？

  • 相较于数组，使用链表更优一些。队列的入队和出队，分别是链表的尾插和头删，不过我们会创建两个指针指向头结点和尾结点，所以不会有时间的消耗。
  • 而数组在头部插入和删除数据，都要挪动数据，效率较低。

链表的数据结构存储的是一个数据变量，和指向下一个结点的指针变量。我们入队列和出队列分别在队尾和队头，所以我们在队列的数据结构定义两个链表的指针变量head和tail，表示队头和队尾

2.2 数据结构设计代码（队列的实现）

跟栈的实现一样，首先要创建三个文件Qtest.c，Queue.c和Queue.h。

  • Qtest.c文件用来测试接口函数是否能成功。
  • Queue.c文件里面放的是各种接口函数实现的代码
  • Queue.h文件放置各种头文件的声明，栈数据结构的设计和接口函数的声明。下面的代码就是放在此文件中。
  1. // 链式结构：表示队列
  2. typedef int QDataType;
  3. typedef struct QueueNode
  4. {
  5. 	struct QueueNode* next;
  6. 	QDataType data;
  7. }QueueNode;
  8.  
  9. // 队列的结构
  10. typedef struct Queue
  11. {
  12. 	QueueNode* head;
  13. 	QueueNode* tail;
  14. }Queue;
  15.  
  16. //初始化队列
  17. void QueueInit(Queue* pq); 
  18. //销毁队列
  19. void QueueDestroy(Queue* pq);
  20. //队尾入队列
  21. void QueuePush(Queue* pq, QDataType x);
  22. //队头出队列
  23. void QueuePop(Queue* pq);
  24. //获取队列头部元素
  25. QDataType QueueFront(Queue* pq);
  26. //获取队列尾部元素
  27. QDataType QueueBack(Queue* pq);
  28. //获取队列中有效元素个数
  29. int QueueSize(Queue* pq);
  30. //检测队列是否为空，如果为空返回true
  31. bool QueueEmpty(Queue* pq);

2.3 接口函数

（1）初始化队列

队列初始化，只需要将队头链表指针和队尾链表指针置为空指针就好。

  1. void QueueInit(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	pq->head = NULL;
  5. 	pq->tail = NULL;
  6. }

（2）销毁队列

因为是以链表为基础，需要用while循环释放掉每一个动态开辟的结点。

  1. void QueueDestroy(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	QueueNode* cur = pq->head;
  5. 	while (cur != NULL)
  6. 	{
  7. 		QueueNode* next = cur->next;
  8. 		free(cur);
  9. 		cur = next;
  10. 	}
  11.  
  12. 	pq->head = pq->tail = NULL;
  13. }

（3）队尾入队列

队尾入队列就是链表的尾插，但是我们有tail指针，直接在tail后面插入就好。不过需要分是否为空队列两种情况，如果是空队列，head和tail指针都指向新结点，如果不是空队列，在tail之后插入。

  1. void QueuePush(Queue* pq, QDataType x)
  2. {
  3. 	assert(pq);
  4. 	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  5. 	if (newnode == NULL)
  6. 	{
  7. 		perror("Queue malloc fail");
  8. 		return;
  9. 	}
  10. 	newnode->data = x;
  11. 	newnode->next = NULL;
  12.  
  13. 	if (pq->head == NULL)
  14. 	{
  15. 		pq->head = pq->tail = newnode;
  16. 	}
  17. 	else
  18. 	{
  19. 		pq->tail->next = newnode;
  20. 		pq->tail = newnode;
  21. 	}
  22. }

（4）队头出队列

在操作之前，我们需要判断队列是否有元素。然后在释放第一个结点，改变指针指向。

  1. void QueuePop(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	assert(!QueueEmpty(pq));
  5.  
  6. 	QueueNode* next = pq->head->next;
  7. 	free(pq->head);
  8. 	pq->head = next;
  9. }

（5）获取队列头部元素

  1. QDataType QueueFront(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	assert(!QueueEmpty(pq));
  5.  
  6. 	return pq->head->data;
  7. }

（6）获取队列尾部元素

  1. QDataType QueueBack(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	assert(!QueueEmpty(pq));
  5.  
  6. 	return pq->tail->data;
  7. }

（7）获取队列中有效元素个数

这需要一个计数变量。

  1. int QueueSize(Queue* pq)
  2. {
  3. 	assert(pq);
  4.  
  5. 	int n = 0;
  6. 	QueueNode* cur = pq->head;
  7. 	while (cur)
  8. 	{
  9. 		n++;
  10. 		cur = cur->next;
  11. 	}
  12.  
  13. 	return n;
  14. }

（8）检测队列是否为空

跟栈判空相同。

  1. bool QueueEmpty(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	return pq->head == NULL;
  5. }

2.4 测试函数

写两个测试函数，第一是入队列和出队列的操作，可以一步一步调试看情况。第二个测试函数，是打印队列里的数据，现获取队头的数据，然后再出队。

  1. void TestQueue1()
  2. {
  3. 	Queue q;
  4. 	QueueInit(&q);
  5. 	QueuePush(&q, 1);
  6. 	QueuePush(&q, 2);
  7. 	QueuePush(&q, 3);
  8. 	QueuePush(&q, 4);
  9.  
  10. 	QueuePop(&q);
  11. 	QueuePop(&q);
  12. 	QueuePop(&q);
  13. 	QueuePop(&q);
  14. 	
  15. 	printf("%d\n", QueueBack(&q));
  16.  
  17. 	QueueDestroy(&q);
  18. }
  19.  
  20. void TestQueue2()
  21. {
  22. 	Queue q;
  23. 	QueueInit(&q);
  24. 	QueuePush(&q, 1);
  25. 	QueuePush(&q, 2);
  26. 	QueuePush(&q, 3);
  27. 	QueuePush(&q, 4);
  28.  
  29. 	while (!QueueEmpty(&q))
  30. 	{
  31. 		QDataType front = QueueFront(&q);
  32. 		printf("%d ", front);
  33. 		QueuePop(&q);
  34. 	}
  35. 	printf("\n");
  36. }
  37.  
  38. int main()
  39. {
  40. 	TestQueue1();
  41. 	TestQueue2();
  42.  
  43. 	return 0;
  44. }

输出的结果：

3. 栈和队列的源代码

3.1 栈

（1）Stack.h

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6.  
  7. typedef int STDataType;
  8.  下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
  9. //typedef int STDataType;
  10. //#define N 10
  11. //typedef struct Stack
  12. //{
  13. //	STDataType _a[N];
  14. //	int _top; // 栈顶
  15. //}Stack;
  16.  
  17. // 支持动态增长的栈
  18. typedef struct Stack
  19. {
  20. 	STDataType* a;
  21. 	int top;      //栈顶
  22. 	int capacity; //容量
  23. }ST;
  24. //初始化栈
  25. void StackInit(ST* ps);
  26. //销毁栈
  27. void StackDestroy(ST* ps);
  28. //压栈
  29. void StackPush(ST* ps, STDataType x);
  30. //出栈
  31. void StackPop(ST* ps);
  32. //获取栈顶元素
  33. STDataType StackTop(ST* ps);
  34. //获取栈中有效元素个数
  35. int StackSize(ST* ps);
  36. //检测栈是否为空，为空返回true
  37. bool StackEmpty(ST* ps);

（2）Stack.c

  1. #include "Stack.h"
  2.  
  3. void StackInit(ST* ps)
  4. {
  5. 	assert(ps);
  6. 	ps->a = NULL;
  7. 	ps->top = 0;//ps->top = -1
  8. 	ps->capacity = 0;
  9. }
  10.  
  11. void StackDestroy(ST* ps)
  12. {
  13. 	assert(ps);
  14. 	free(ps->a);
  15. 	ps->a = NULL;
  16. 	ps->top = ps->capacity = 0;
  17. }
  18.  
  19. void StackPush(ST* ps, STDataType x)
  20. {
  21. 	assert(ps);
  22.  
  23. 	if (ps->top == ps->capacity)
  24. 	{
  25. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  26. 		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
  27. 		if (tmp == NULL)
  28. 		{
  29. 			printf("realloc fail\n");
  30. 			exit(-1);
  31. 		}
  32.  
  33. 		ps->a = tmp;
  34. 		ps->capacity = newCapacity;
  35. 	}
  36.  
  37. 	ps->a[ps->top] = x;
  38. 	ps->top++;
  39. }
  40.  
  41. void StackPop(ST* ps)
  42. {
  43. 	assert(ps);
  44. 	assert(!StackEmpty(ps));
  45.  
  46. 	ps->top--;
  47. }
  48.  
  49. STDataType StackTop(ST* ps)
  50. {
  51. 	assert(ps);
  52. 	assert(!StackEmpty(ps));
  53.  
  54. 	return ps->a[ps->top - 1];
  55. }
  56.  
  57. int StackSize(ST* ps)
  58. {
  59. 	assert(ps);
  60.  
  61. 	return ps->top;
  62. }
  63.  
  64. bool StackEmpty(ST* ps)
  65. {
  66. 	assert(ps);
  67.  
  68. 	return ps->top == 0;
  69. }

（3）STtest.c

  1. #include "Stack.h"
  2.  
  3. void TestStack1()
  4. {
  5. 	ST st;
  6. 	StackInit(&st);
  7.  
  8. 	StackPush(&st, 1);
  9. 	StackPush(&st, 2);
  10. 	StackPush(&st, 3);
  11. 	StackPush(&st, 4);
  12.  
  13. 	StackPop(&st);
  14. 	StackPop(&st);
  15. 	StackPop(&st);
  16. 	StackPop(&st);
  17. 	StackPop(&st);
  18.  
  19. 	StackDestroy(&st);
  20. }
  21.  
  22. void TestStack2()
  23. {
  24. 	ST st;
  25. 	StackInit(&st);
  26.  
  27. 	StackPush(&st, 1);
  28. 	StackPush(&st, 2);
  29. 	StackPush(&st, 3);
  30. 	StackPush(&st, 4);
  31.  
  32. 	//printf("%d ", StackTop(&st));
  33. 	//StackPop(&st);
  34. 	//printf("%d ", StackTop(&st));
  35. 	//StackPop(&st);
  36.  
  37. 	//StackPush(&st, 5);
  38. 	//StackPush(&st, 6);
  39.  
  40. 	while (!StackEmpty(&st))
  41. 	{
  42. 		printf("%d ", StackTop(&st));
  43. 		StackPop(&st);
  44. 	}
  45.  
  46. 	StackDestroy(&st);
  47. }
  48.  
  49. int main()
  50. {
  51. 	TestStack1();
  52. 	//TestStack2();
  53.  
  54. 	return 0;
  55. }

3.2 队列

（1）Queue.h

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6.  
  7. // 链式结构：表示队列
  8. typedef int QDataType;
  9. typedef struct QueueNode
  10. {
  11. 	struct QueueNode* next;
  12. 	QDataType data;
  13. }QueueNode;
  14.  
  15. // 队列的结构
  16. typedef struct Queue
  17. {
  18. 	QueueNode* head;
  19. 	QueueNode* tail;
  20. }Queue;
  21.  
  22. //初始化队列
  23. void QueueInit(Queue* pq); 
  24. //销毁队列
  25. void QueueDestroy(Queue* pq);
  26. //队尾入队列
  27. void QueuePush(Queue* pq, QDataType x);
  28. //队头出队列
  29. void QueuePop(Queue* pq);
  30. //获取队列头部元素
  31. QDataType QueueFront(Queue* pq);
  32. //获取队列尾部元素
  33. QDataType QueueBack(Queue* pq);
  34. //获取队列中有效元素个数
  35. int QueueSize(Queue* pq);
  36. //检测队列是否为空，如果为空返回true
  37. bool QueueEmpty(Queue* pq);

（2）Queue.c

  1. #include "Queue.h"
  2.  
  3. void QueueInit(Queue* pq)
  4. {
  5. 	assert(pq);
  6. 	pq->head = NULL;
  7. 	pq->tail = NULL;
  8. }
  9.  
  10. void QueueDestroy(Queue* pq)
  11. {
  12. 	assert(pq);
  13. 	QueueNode* cur = pq->head;
  14. 	while (cur != NULL)
  15. 	{
  16. 		QueueNode* next = cur->next;
  17. 		free(cur);
  18. 		cur = next;
  19. 	}
  20.  
  21. 	pq->head = pq->tail = NULL;
  22. }
  23.  
  24. void QueuePush(Queue* pq, QDataType x)
  25. {
  26. 	assert(pq);
  27. 	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  28. 	if (newnode == NULL)
  29. 	{
  30. 		perror("Queue malloc fail");
  31. 		return;
  32. 	}
  33. 	newnode->data = x;
  34. 	newnode->next = NULL;
  35.  
  36. 	if (pq->head == NULL)
  37. 	{
  38. 		pq->head = pq->tail = newnode;
  39. 	}
  40. 	else
  41. 	{
  42. 		pq->tail->next = newnode;
  43. 		pq->tail = newnode;
  44. 	}
  45. }
  46.  
  47. void QueuePop(Queue* pq)
  48. {
  49. 	assert(pq);
  50. 	assert(!QueueEmpty(pq));
  51.  
  52. 	QueueNode* next = pq->head->next;
  53. 	free(pq->head);
  54. 	pq->head = next;
  55. }
  56.  
  57.  
  58. QDataType QueueFront(Queue* pq)
  59. {
  60. 	assert(pq);
  61. 	assert(!QueueEmpty(pq));
  62.  
  63. 	return pq->head->data;
  64. }
  65.  
  66. QDataType QueueBack(Queue* pq)
  67. {
  68. 	assert(pq);
  69. 	assert(!QueueEmpty(pq));
  70.  
  71. 	return pq->tail->data;
  72. }
  73.  
  74. int QueueSize(Queue* pq)
  75. {
  76. 	assert(pq);
  77.  
  78. 	int n = 0;
  79. 	QueueNode* cur = pq->head;
  80. 	while (cur)
  81. 	{
  82. 		n++;
  83. 		cur = cur->next;
  84. 	}
  85.  
  86. 	return n;
  87. }
  88.  
  89. bool QueueEmpty(Queue* pq)
  90. {
  91. 	assert(pq);
  92. 	return pq->head == NULL;
  93. }

（3）Qtest.c

  1. void TestQueue1()
  2. {
  3. 	Queue q;
  4. 	QueueInit(&q);
  5. 	QueuePush(&q, 1);
  6. 	QueuePush(&q, 2);
  7. 	QueuePush(&q, 3);
  8. 	QueuePush(&q, 4);
  9.  
  10. 	QueuePop(&q);
  11. 	QueuePop(&q);
  12. 	QueuePop(&q);
  13. 	QueuePop(&q);
  14. 	
  15. 	printf("%d\n", QueueBack(&q));
  16.  
  17. 	QueueDestroy(&q);
  18. }
  19.  
  20. void TestQueue2()
  21. {
  22. 	Queue q;
  23. 	QueueInit(&q);
  24. 	QueuePush(&q, 1);
  25. 	QueuePush(&q, 2);
  26. 	QueuePush(&q, 3);
  27. 	QueuePush(&q, 4);
  28.  
  29. 	while (!QueueEmpty(&q))
  30. 	{
  31. 		QDataType front = QueueFront(&q);
  32. 		printf("%d ", front);
  33. 		QueuePop(&q);
  34. 	}
  35. 	printf("\n");
  36. }
  37.  
  38. int main()
  39. {
  40. 	//TestQueue1();
  41. 	TestQueue2();
  42. 	return 0;
  43. }

总结

栈和队列的实现其实相较于链表的实现简单一些，是因为其结构的特殊要求。之后会出一篇关于栈和队列的OJ题目。多多重复，百炼成钢！

创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！

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

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

  

闽ICP备14008679号