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

万字详解！C语言数据结构栈和队列_c语言创建并初始化一个栈,这个栈的节点是空节点吗

作者：码创造者 | 2024-07-01 10:42:16

赞

踩

c语言创建并初始化一个栈,这个栈的节点是空节点吗

目录

栈和队列

一、数组栈

1.1栈的数据结构为

1.2栈的初始化

1.3进栈操作

1.4判断栈是否为空

1.5销毁栈

1.6完整代码

二、两栈共享空间

2.1数据结构为

2.2初始化栈 置空栈

2.3判断栈是否为空

2.4插入元素到栈中

2.5出栈

2.6完整代码

三、队列

3.1队列的数据结构

3.2队列的初始化

3.3 销毁队列

3.4 从尾部插入数据到队列

3.5判断队列是否为空

3.6从头开始删除一个结点

3.7返回前一个结点

3.8返回队尾的元素

3.9返回队列的大小

4.0完整代码

栈和队列

概述： 栈（Stack）是一种具有特定存储结构的数据结构，它遵循先进后出的原则，即最后进入的元素首先被访问和删除。栈的基本操作包括进栈，出栈，销毁栈。栈分为数组栈和链式栈。

一、数组栈

概述： 数组栈用数组来存数据

1.1栈的数据结构为

  1. typedef int STDtype;
  2. typedef struct stack
  3. {
  4. 	STDtype* data;	// 指向栈数组的指针 定义为指针方便动态扩展内存
  5. 	int top;	    // 记录栈的顶点
  6. 	int capacity;	// 记录栈的容量
  7. } ST;

1.2栈的初始化

初始化栈就是把容量数据顶点都置零

  1. // 初始化栈
  2. void InitStack(ST* ps)
  3. {
  4. 	ps->capacity = 0;
  5. 	ps->data = NULL;
  6.     // top 可以给0或者1 给0意味着top 指向栈顶数据的下一个，所以在用时先给数据再加一
  7. 	// top 等于 -1时 要先加1 再给数据 
  8. 	ps->top = 0;  // ps->top = -1;
  9. }

1.3进栈操作

  1. // 插入栈数据
  2. // 1. 先判断是否满容量 满容量就扩容
  3. // 2. 扩容完检测是否扩容成功，不成功打印错误信息并退出程序
  4. // 3. 扩容成功指向新的空间 更新新的容量大小
  5. // 4. 插入数据
  6. void StackPush(ST* ps, STDtype e)
  7. {
  8. 	assert(ps);
  9. 	if (ps->capacity == ps->top) // 当栈顶等于容量时说明 没有容量了
  10. 	{
  11. 		// 没有容量有两种情况 1. 没有一个容量，四个容量 2. 容量达到设定容量了
  12. 		// 申请新的容量 为原来容量的2 倍。
  13. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  14. 		STDtype* temp = realloc(ps->data, sizeof(STDtype) * newCapacity);  // // 给ps->data 扩容，如果ps->data 为空则申请空间
  15. 		if (temp == NULL)
  16. 		{
  17. 			printf("realloc faill\n");
  18. 			exit(-1);
  19. 		}
  20. 		ps->data = temp;		    // 扩容成功 指向新的空间
  21. 		ps->capacity = newCapacity;  // 更新新的容量
  22. 	}
  23.  
  24. 	ps->data[ps->top] = e;
  25. 	ps->top++;  
  26. }

1.4判断栈是否为空

  1. // 判断栈是否为空
  2. bool StackEmpty(ST* ps)
  3. {
  4. 	return ps->top == 0;
  5. }

注意： 上面的函数返回值为bool C语言中要使用bool 需要包含头文件 #include <stdbool.h>

1.5出栈操作

  1. // 出栈
  2. // 1. 判断栈是否为空，为空则返回0
  3. // 2. 不为空用变量记录栈顶数据
  4. // 3. 栈顶指针减1
  5. // 4. 返回开始记录的栈顶数据
  6. STDtype StackPop(ST* ps)
  7. {
  8. 	if (StackEmpty(ps))  // 判断是否为空
  9. 	{
  10. 		return 0;		// 为空返回0
  11. 	}
  12. 	else
  13. 	{
  14. 		STDtype temp = ps->data[ps->top-1];		  // 记录栈顶数据
  15. 		ps->top--;							    // 栈顶指针减减
  16. 		return temp;							// 返回记录的栈顶
  17. 	}
  18. }

1.5销毁栈

  1. // 销毁栈
  2. // 1.释放指针
  3. // 2.将指针和容量指向0
  4. void StackDestory(ST* ps)
  5. {
  6. 	// 释放指针维护的数据
  7. 	free(ps->data);
  8. 	// 数据指针和容量指向0
  9. 	// 数据指针将其设置为0 意味着将其指向空地址。
  10. 	ps->data = NULL;
  11. 	ps->capacity = 0;
  12. }

1.6完整代码

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdbool.h>
  6. #include <assert.h>
  7.  
  8. typedef int STDtype;
  9. typedef struct stack
  10. {
  11. 	STDtype* data;
  12. 	int top;
  13. 	int capacity;
  14. } ST;
  15.  
  16. // 初始化栈
  17. void InitStack(ST* ps)
  18. {
  19. 	ps->capacity = 0;
  20. 	ps->data = NULL;
  21. 	ps->top = 0;  // 这里初始化为0 指向栈
  22. }
  23.  
  24. // 插入栈数据
  25. // 1. 先判断是否满容量 满容量就扩容
  26. // 2. 扩容完检测是否扩容成功，不成功打印错误信息并退出程序
  27. // 3. 扩容成功指向新的空间 更新新的容量大小
  28. // 4. 插入数据
  29. void StackPush(ST* ps, STDtype e)
  30. {
  31. 	assert(ps);
  32. 	if (ps->capacity == ps->top) // 当栈顶等于 容量时说明 没有容量了
  33. 	{
  34. 		// 没有容量有两种情况 1. 没有一个容量，四个容量 2. 容量达到设定容量了
  35. 		// 申请新的容量 为原来容量的2 倍。
  36. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  37. 		STDtype* temp = realloc(ps->data, sizeof(STDtype) * newCapacity);  // // 给ps->data 扩容，如果ps->data 为空则申请空间
  38. 		if (temp == NULL)
  39. 		{
  40. 			printf("realloc faill\n");
  41. 			exit(-1);
  42. 		}
  43. 		ps->data = temp;		    // 扩容成功 指向新的空间
  44. 		ps->capacity = newCapacity; // 更新新的容量
  45. 	}
  46.  
  47. 	ps->data[ps->top] = e;
  48. 	ps->top++;  
  49. }
  50.  
  51. // 判断栈是否为空
  52. bool StackEmpty(ST* ps)
  53. {
  54. 	return ps->top == 0;
  55. }
  56.  
  57. // 出栈
  58. // 1. 判断栈是否为空，为空则返回0
  59. // 2. 不为空用变量记录栈顶数据
  60. // 3. 栈顶指针减1
  61. // 4. 返回开始记录的栈顶数据
  62. STDtype StackPop(ST* ps)
  63. {
  64. 	if (StackEmpty(ps))  // 判断是否为空
  65. 	{
  66. 		return 0;		 // 为空返回0
  67. 	}
  68. 	else
  69. 	{
  70. 		STDtype temp = ps->data[ps->top-1];		// 记录栈顶数据
  71. 		ps->top--;							    // 栈顶指针减减
  72. 		return temp;							// 返回记录的栈顶
  73. 	}
  74. }
  75.  
  76. // 销毁栈
  77. // 1.释放指针
  78. // 2.将指针和容量指向0
  79. void StackDestory(ST* ps)
  80. {
  81. 	// 释放指针维护的数据
  82. 	free(ps->data);
  83. 	// 数据指针和容量指向0
  84. 	// 数据指针将其设置为0 意味着将其指向空地址。
  85. 	ps->data = NULL;
  86. 	ps->capacity = 0;
  87. }
  88.  
  89. void test01(void)
  90. {
  91. 	ST ps;
  92. 	InitStack(&ps);			// 初始化栈
  93.  
  94. 	// 栈插入数据
  95. 	StackPush(&ps, 1);
  96. 	StackPush(&ps, 2);
  97. 	StackPush(&ps, 3);
  98. 	StackPush(&ps, 4);
  99. 	
  100.     // 若栈不为空则出栈并打印
  101. 	while (!StackEmpty(&ps))
  102. 	{
  103. 		printf("%d ", StackPop(&ps));
  104. 	}
  105. 	
  106. 	StackDestory(&ps);		// 释放栈空间
  107. }
  108.  
  109. int main(void)
  110. {
  111. 	test01();
  112. 	return 0;
  113. }

二、两栈共享空间

概述： 当两个栈的空间需求相反时，如一个增加另一个减少，适合使用两栈共享空间

让一个栈的栈底为数组的始端即下标为0 处，另外一个为数组的末端即下标为n-1处。如果有元素就增加就像两端靠拢。

2.1数据结构为

  1. // 定义两栈的数据结构
  2. #define MAXSIZE 20
  3. typedef int STDtype;
  4. typedef struct Stack
  5. {
  6. 	STDtype data[MAXSIZE];
  7. 	int top1;  // 指向栈1的顶指针
  8. 	int top2;  // 指向栈2的顶指针
  9. }ST;

初始top1 可以使它指向-1 也可以使它指向0 指向-1 后再后面的运算时要先移动再运算，top2 也样的。

2.2初始化栈 置空栈

  1. // 初始化栈
  2. // 1. 把栈顶指针top1 指向-1 所以在进栈的时候要先移动指针再 进行赋值操作 
  3. //      栈顶指针top2 指向的是MAXSIZE 进栈时也要先移动指针再赋值
  4. void StackInit(ST* ps)
  5. {
  6. 	ps->top1 = -1;
  7. 	ps->top2 = MAXSIZE;
  8. }
  9.  
  10. // 置空栈
  11. // 置空栈就是让他们的顶指针复位
  12. void StackDestory(ST* ps)
  13. {
  14. 	ps->top1 = -1;
  15. 	ps->top2 = MAXSIZE;
  16. }

2.3判断栈是否为空

当top1 和 top2 都指向初始值时 此时栈为空

  1. // 判断栈是否为空
  2. // 为空返回1 
  3. bool StackEmpty(ST* ps)
  4. {
  5. 	return (ps->top1 == -1 && ps->top2 == MAXSIZE);
  6. }

2.4插入元素到栈中

  1. // 插入元素到栈中
  2. // 参数1 栈的指针
  3. // 参数2 插入的数据
  4. // 参数3 给第几个栈插入
  5. // 方法
  6. // 1. 先判断容量是否满了 满了就退出
  7. // 2. 判断是插入到哪个栈
  8. // 3. 插入数据
  9.  
  10. void StackPush(ST* ps, STDtype e, int stackNumber)
  11. {
  12. 	if (ps->top1 + 1 == ps->top2)
  13. 	{
  14. 		printf("栈满不能进栈\n");
  15. 		exit(-1);
  16. 	}
  17. 		
  18. 	if (stackNumber == 1)
  19. 	{
  20. 		ps->data[++ps->top1] = e; // 栈顶指针指向的是前一个 每次进栈时要先移动栈顶指针再赋值
  21. 	}
  22. 	else if (stackNumber == 2)
  23. 	{
  24. 		ps->data[--ps->top2] = e; // 栈顶指针指向的是后一个 每次进栈时要先移动栈顶指针再赋值
  25. 	}
  26. }

2.5出栈

  1. // 出栈
  2. // 参数1 栈指针
  3. // 参数2 第几个栈
  4. // 方法
  5. // 1. 先判断栈是否为空
  6. // 2. 选择哪个栈出栈
  7. //
  8. STDtype StackPop(ST* ps, int stackNumber)
  9. {
  10. 	if (StackEmpty(ps))
  11. 	{
  12. 		printf("栈为空不能出栈\n");
  13. 		return -1;	
  14. 	}
  15. 		
  16. 	if (1 == stackNumber)
  17. 	{
  18. 		return ps->data[ps->top1 --]; // 进完栈 栈顶指针指向的是当前的值 所以出完栈后再进行减减
  19. 	}
  20. 	else if (2 == stackNumber)
  21. 	{
  22. 		return ps->data[ps->top2++]; // 进完栈 栈顶指针指向的是当前的值 所以出完栈后再进行加加
  23. 	}
  24. }

注意：出栈时的顶指针移动顺序和初始化时的值有关。

2.6完整代码

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdbool.h>
  4.  
  5. // 定义两栈的数据结构
  6. #define MAXSIZE 20
  7. typedef int STDtype;
  8. typedef struct Stack
  9. {
  10. 	STDtype data[MAXSIZE];
  11. 	int top1;  // 指向栈1的顶指针
  12. 	int top2;  // 指向栈2的顶指针
  13. }ST;
  14.  
  15. // 初始化栈
  16. // 1. 把栈顶指针1 指向-1 所以在进栈的时候要先移动指针再 进行赋值操作 栈顶指针2 指向的是MAXSIZE 进栈时也要先移动指针再赋值
  17. void StackInit(ST* ps)
  18. {
  19. 	ps->top1 = -1;
  20. 	ps->top2 = MAXSIZE;
  21. }
  22.  
  23. // 把栈置空
  24. void StackDestory(ST* ps)
  25. {
  26. 	ps->top1 = -1;
  27. 	ps->top2 = MAXSIZE;
  28. }
  29.  
  30. // 判断栈是否为空
  31. // 为空返回1 
  32. bool StackEmpty(ST* ps)
  33. {
  34. 	return (ps->top1 == -1 && ps->top2 == MAXSIZE);
  35.  
  36. }
  37.  
  38. // 插入元素到栈中
  39. // 参数1 栈的指针
  40. // 参数2 插入的数据
  41. // 参数3 给第几个栈插入
  42. // 方法
  43. // 1. 先判断容量是否满了 满了就退出
  44. // 2. 判断是插入到哪个栈
  45. // 3. 插入数据
  46.  
  47. void StackPush(ST* ps, STDtype e, int stackNumber)
  48. {
  49. 	if (ps->top1 + 1 == ps->top2)
  50. 	{
  51. 		printf("栈满不能进栈\n");
  52. 		exit(-1);
  53. 	}
  54. 		
  55. 	if (stackNumber == 1)
  56. 	{
  57. 		ps->data[++ps->top1] = e; // 栈顶指针指向的是前一个 每次进栈时要先移动栈顶指针再赋值
  58. 	}
  59. 	else if (stackNumber == 2)
  60. 	{
  61. 		ps->data[--ps->top2] = e; // 栈顶指针指向的是后一个 每次进栈时要先移动栈顶指针再赋值
  62. 	}
  63. }
  64.  
  65. // 出栈
  66. // 参数1 栈指针
  67. // 参数2 第几个栈
  68. // 方法
  69. // 1. 先判断栈是否为空
  70. // 2. 选择哪个栈出栈
  71. //
  72. STDtype StackPop(ST* ps, int stackNumber)
  73. {
  74. 	if (StackEmpty(ps))
  75. 	{
  76. 		printf("栈为空不能出栈\n");
  77. 		return -1;	
  78. 	}
  79. 		
  80. 	if (1 == stackNumber)
  81. 	{
  82. 		return ps->data[ps->top1 --]; // 进完栈 栈顶指针指向的是当前的值 所以出完栈后再进行减减
  83. 	}
  84. 	else if (2 == stackNumber)
  85. 	{
  86. 		return ps->data[ps->top2++]; // 进完栈 栈顶指针指向的是当前的值 所以出完栈后再进行加加
  87. 	}
  88. }
  89.  
  90. void test01(void)
  91. {
  92. 	ST ps;
  93. 	// 初始化栈
  94. 	StackInit(&ps);
  95.  
  96. 	// 给栈插入数据
  97. 	StackPush(&ps, 1, 1);
  98. 	StackPush(&ps, 2, 1);
  99. 	StackPush(&ps, 3, 1);
  100.  
  101. 	StackPush(&ps, 3, 2);
  102. 	StackPush(&ps, 2, 2);
  103. 	StackPush(&ps, 1, 2);
  104.  
  105. 	// 出栈
  106. 	printf("%d ", StackPop(&ps, 1));
  107. 	printf("%d ", StackPop(&ps, 1));
  108. 	printf("%d ", StackPop(&ps, 1));
  109.  
  110. 	printf("%d ", StackPop(&ps, 2));
  111. 	printf("%d ", StackPop(&ps, 2));
  112. 	printf("%d ", StackPop(&ps, 2));
  113.  
  114. 	// 清除栈
  115. 	StackDestory(&ps);
  116. }
  117.  
  118. int main(void)
  119. {
  120. 	/*test01();*/
  121. 	ST ps;
  122. 	test01();
  123. 	// 清除栈
  124. 	StackDestory(&ps);
  125. 	return 0;
  126. }

三、队列

概述：只允许在一端插入数据 在另一端删除数据的线性表，队列具有先进先出

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

出队列：进行删除一端为队头

3.1队列的数据结构

队列可以用数组来实现也可以用链来实现，但链实现的队列更加节省空间。如下是用链表实现的队列。

  1. // 链队列的数据结构
  2. typedef int QDataType;
  3. typedef struct QueueNode
  4. {
  5. 	struct QueueNode* next;
  6. 	QDataType data;
  7. }QueueNode;

通常为了操作队列会定义一个头指针和尾指针，队列在此头结点创建，一般会用结构体封装一下。如下

  1. // 定义头指针和尾指针
  2. typedef struct Queue
  3. {
  4. 	QueueNode* head;
  5. 	QueueNode* tail;
  6. }Queue;

3.2队列的初始化

初始化队列就是初始化好头结点和尾结点。如下

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

3.3 销毁队列

依次释放队列的每个元素，和单链表的释放类似

  1. // 释放结点信息
  2. void QueueDestory(Queue* pq)
  3. {
  4. 	assert(pq);
  5. 	QueueNode* cur = pq->head;		// 定义工作指针从头开始释放结点
  6. 	while (cur != NULL)			    // 目前结点不为空就一直执行
  7. 	{
  8. 		QueueNode* next = cur->next; // 临时存储下一个结点
  9. 		free(cur);				    // 释放当前结点
  10. 		cur = next;				    // 指向存储的结点
  11. 	}
  12. 	pq->head = pq->tail = NULL;		 // 释放完给头尾结点指针置空
  13. }

3.4 入队列

入队列就是从队尾插入数据

  1. // 插入数据到队列
  2. // 创建新结点 给结点数据赋值
  3. // 链接新结点到队尾
  4. void QueuePush(Queue* pq, QDataType x)
  5. {
  6. 	assert(pq);
  7. 	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));		// 创建新的结点
  8. 	newnode->data = x;			// 给结点数据赋值
  9. 	newnode->next = NULL;		// 结点的尾置空
  10. 	if (pq->head == NULL)		// 当插入的是第一个结点时
  11. 	{
  12. 		pq->head = pq->tail = newnode;	// 头结点和尾结点 都指向这个节点
  13. 	}
  14. 	else
  15. 	{
  16. 		pq->tail->next = newnode;  // 尾结点的下一个指向新结点
  17. 		pq->tail = newnode;		  //  更新尾结点为刚刚插入的新结点
  18. 	}
  19.  }

注意： 当第一次插入数据时要判断

3.5判断队列是否为空

判断头是否为空就能得出队列是否为空

  1. // 判断是否为空
  2. bool QueueEmpty(Queue* pq)
  3. {
  4. 	assert(pq);
  5. 	return pq->head == NULL;
  6. }

3.6删除队头一个结点

删除的是头结点或头的后继结点，看队列定义的时候头结点是否也存储信息，如存储就从头开始删除，如不存储就从头的下一结点删除。

如下头结点也是有效结点，所以出队列就是删除现有头结点再更新头结点。

  1. // 删除结点
  2. void QueuePop(Queue* pq)
  3. {
  4. 	assert(pq);
  5. 	// 不等于空 等于就保错 提示
  6. 	assert(!QueueEmpty(pq));
  7. 	QueueNode* next = pq->head->next; // 临时保存要删结点的下一结点
  8. 	free(pq->head);					  // 删除结点
  9. 	pq->head = next;				  // 更新头结点到下一结点
  10. 	if (pq->head == NULL)
  11. 	{
  12. 		pq->tail = NULL;  // 当删除完结点head 为空时 tail 也应该为空 不然tail 是一个野指针
  13. 	}
  14. }

3.7返回前一个结点

前一个结点相当于队头的数据

  1. // 返回队列前一个数
  2. QDataType QueueFront(Queue* pq)
  3. {
  4. 	assert(pq);
  5. 	assert(!QueueEmpty(pq));
  6.  
  7. 	return pq->head->data;
  8. }

注意：出队列就是先返回队头一个结点，然后再删除队头一个结点。即上面两步的结合组成出队列操作也可以把上面两步合为一步。

3.8返回队尾的元素

  1. // 返回队列后一个数
  2. QDataType QueueBack(Queue* pq)
  3. {
  4. 	assert(pq);
  5. 	assert(!QueueEmpty(pq));
  6.  
  7. 	return pq->tail->data;
  8. }

3.9返回队列的大小

队列的大小可以在定义的时候多定义一个变量来记录，也可以现用现求。如下是现用现求。

  1. int QueueSize(Queue* pq)
  2. {
  3. 	assert(pq);
  4. 	int size = 0;	// 定义记录变量
  5. 	QueueNode* cur = pq->head; // 定义工作结点	
  6. 	while (cur)		// 当当前结点为空时 退出
  7. 	{
  8. 		++size;		// 记录大小
  9. 		cur = cur->next;  // 更新节点
  10. 	}
  11. 	return size;	// 返回大小
  12. }

3.10 完整代码

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <stdio.h>
  4. #include <stdbool.h>
  5. #include <assert.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. 	assert(pq);
  26. 	pq->head = NULL;
  27. 	pq->tail = NULL;
  28. }
  29. // 释放结点信息
  30. void QueueDestory(Queue* pq)
  31. {
  32. 	assert(pq);
  33. 	QueueNode* cur = pq->head;
  34. 	while (cur != NULL)
  35. 	{
  36. 		QueueNode* next = cur->next;
  37. 		free(cur);
  38. 		cur = next;
  39. 	}
  40. 	pq->head = pq->tail = NULL;
  41. }
  42.  
  43. // 插入数据到队列
  44. // 创建新结点 给结点数据赋值
  45. // 
  46. void QueuePush(Queue* pq, QDataType x)
  47. {
  48. 	assert(pq);
  49. 	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  50. 	newnode->data = x;
  51. 	newnode->next = NULL;
  52. 	if (pq->head == NULL)
  53. 	{
  54. 		pq->head = pq->tail = newnode;
  55. 	}
  56. 	else
  57. 	{
  58. 		pq->tail->next = newnode;
  59. 		pq->tail = newnode;
  60. 	}
  61.  
  62. }
  63. // 判断是否为空
  64. bool QueueEmpty(Queue* pq)
  65. {
  66. 	assert(pq);
  67. 	return pq->head == NULL;
  68. }
  69.  
  70. // 删除结点前一个节点 从头结点开始删
  71. void QueuePop(Queue* pq)
  72. {
  73. 	assert(pq);
  74. 	// 不等于空 等于就保错 提示
  75. 	assert(!QueueEmpty(pq));
  76. 	QueueNode* next = pq->head->next;
  77. 	free(pq->head);
  78. 	pq->head = next;
  79. 	if (pq->head == NULL)
  80. 	{
  81. 		pq->tail = NULL;  // d当head 出完为空时 tail 也应该为空 不然tail 是一个野指针
  82. 	}
  83. }
  84.  
  85. // 返回队列前一个数
  86. QDataType QueueFront(Queue* pq)
  87. {
  88. 	assert(pq);
  89. 	assert(!QueueEmpty(pq));
  90.  
  91. 	return pq->head->data;
  92. }
  93.  
  94. // 返回队列后一个数
  95. QDataType QueueBack(Queue* pq)
  96. {
  97. 	assert(pq);
  98. 	assert(!QueueEmpty(pq));
  99.  
  100. 	return pq->tail->data;
  101. }
  102. int QueueSize(Queue* pq)
  103. {
  104. 	assert(pq);
  105. 	int n = 0;
  106. 	QueueNode* cur = pq->head;
  107. 	while (cur)
  108. 	{
  109. 		++n;
  110. 		cur = cur->next;
  111. 	}
  112. 	return n;
  113. }
  114.  
  115. void test01()
  116. {
  117. 	Queue q; // 创建头指针
  118. 	QueueInit(&q);
  119.  
  120. 	QueuePush(&q, 1);
  121. 	QueuePush(&q, 2);
  122. 	QueuePush(&q, 3);
  123. 	QueuePush(&q, 4);
  124. 	QueuePush(&q, 5);
  125.  
  126. 	QueuePop(&q);		// 删除一个节点 从前面开始删
  127. 	printf("%d \n", QueueSize(&q));
  128.  
  129. 	while (!QueueEmpty(&q))	// 遍历队列 遍历一个删除一个 
  130. 	{
  131. 		QDataType front = QueueFront(&q);
  132. 		printf("%d ", front);
  133. 		QueuePop(&q);	// 删除一个队列
  134. 	}
  135. 		
  136. 	QueueDestory(&q); // 销毁队列
  137. }
  138.  
  139. int main(void)
  140. {
  141. 	test01();
  142. 	return 0;
  143. }

运行结果

  1.  4
  2. 2 3 4 5

上一篇：C语言数据结构单链表详解

下一篇：

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

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

  

闽ICP备14008679号