链式队列

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #include "math.h"
  4. #include "time.h"
  5. #define OK 1
  6. #define ERROR 0
  7. #define TRUE 1
  8. #define FALSE 0
  9. #define MAXSIZE 20 /* 存储空间初始分配量 */
  10. typedef int Status;
  11. typedef int QElemType; /* QElemType类型根据实际情况而定,这里假设为int */
  12. typedef struct QNode /* 结点结构 */
  13. {
  14. QElemType data;
  15. struct QNode *next;
  16. }QNode, *QueuePtr;
  17. typedef struct /* 队列的链表结构 */
  18. {
  19. QueuePtr front, rear; /* 队头、队尾指针 */
  20. }LinkQueue;
  21. Status visit(QElemType c)
  22. {
  23. printf("%d ", c);
  24. return OK;
  25. }
  26. /* 构造一个空队列Q */
  27. Status InitQueue(LinkQueue *Q)
  28. {
  29. Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
  30. if (!Q->front)
  31. exit(OVERFLOW);
  32. Q->front->next = NULL;
  33. return OK;
  34. }
  35. /* 销毁队列Q */
  36. Status DestroyQueue(LinkQueue *Q)
  37. {
  38. while (Q->front)//当Q->front不为空的时候,即队列中还有元素时执行这个while循环
  39. {
  40. Q->rear = Q->front->next;//删除的都是队首元素,里用Q->rear来储存Q->front->next
  41. free(Q->front);
  42. Q->front = Q->rear;
  43. }
  44. return OK;
  45. }
  46. /* 将Q清为空队列 */
  47. Status ClearQueue(LinkQueue *Q)
  48. {
  49. QueuePtr p, q;
  50. Q->rear = Q->front;
  51. p = Q->front->next;
  52. Q->front->next = NULL;//已经被p储存起来了。
  53. while (p)//当队列还没空
  54. {
  55. q = p;
  56. p = p->next;
  57. free(q);
  58. }
  59. return OK;
  60. }
  61. /* 若Q为空队列,则返回TRUE,否则返回FALSE */
  62. Status QueueEmpty(LinkQueue Q)
  63. {
  64. if (Q.front == Q.rear)
  65. return TRUE;
  66. else
  67. return FALSE;
  68. }
  69. /* 求队列的长度 */
  70. int QueueLength(LinkQueue Q)
  71. {
  72. int i = 0;
  73. QueuePtr p;
  74. p = Q.front;
  75. while (Q.rear != p)
  76. {
  77. i++;
  78. p = p->next;
  79. }
  80. return i;
  81. }
  82. /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
  83. Status GetHead(LinkQueue Q, QElemType *e)
  84. {
  85. QueuePtr p;
  86. if (Q.front == Q.rear)
  87. return ERROR;
  88. p = Q.front->next;
  89. *e = p->data;
  90. return OK;
  91. }
  92. /* 插入元素e为Q的新的队尾元素 */
  93. Status EnQueue(LinkQueue *Q, QElemType e)
  94. {
  95. QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
  96. if (!s) /* 存储分配失败 */
  97. exit(OVERFLOW);
  98. s->data = e;
  99. s->next = NULL;
  100. Q->rear->next = s; /* 把拥有元素e的新结点s赋值给原队尾结点的后继,见图中① */
  101. Q->rear = s; /* 把当前的s设置为队尾结点,rear指向s,见图中② */
  102. return OK;
  103. }
  104. /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
  105. Status DeQueue(LinkQueue *Q, QElemType *e)
  106. {
  107. QueuePtr p;
  108. if (Q->front == Q->rear)
  109. return ERROR;
  110. p = Q->front->next; /* 将欲删除的队头结点暂存给p,见图中① */
  111. *e = p->data; /* 将欲删除的队头结点的值赋值给e */
  112. Q->front->next = p->next;/* 将原队头结点的后继p->next赋值给头结点后继,见图中② */
  113. if (Q->rear == p) /* 若队头就是队尾,则删除后将rear指向头结点,见图中③ */
  114. Q->rear = Q->front;
  115. free(p);
  116. return OK;
  117. }
  118. /* 从队头到队尾依次对队列Q中每个元素输出 */
  119. Status QueueTraverse(LinkQueue Q)
  120. {
  121. QueuePtr p;
  122. p = Q.front->next;
  123. while (p)
  124. {
  125. visit(p->data);
  126. p = p->next;
  127. }
  128. printf("\n");
  129. return OK;
  130. }
  131. int main()
  132. {
  133. int i;
  134. QElemType d;
  135. LinkQueue q;
  136. i = InitQueue(&q);
  137. if (i)
  138. printf("成功地构造了一个空队列!\n");
  139. printf("是否空队列?%d(1:空 0:否) ", QueueEmpty(q));
  140. printf("队列的长度为%d\n", QueueLength(q));
  141. EnQueue(&q, -5);
  142. EnQueue(&q, 5);
  143. EnQueue(&q, 10);
  144. printf("插入3个元素(-5,5,10)后,队列的长度为%d\n", QueueLength(q));
  145. printf("是否空队列?%d(1:空 0:否) ", QueueEmpty(q));
  146. printf("队列的元素依次为:");
  147. QueueTraverse(q);
  148. i = GetHead(q, &d);
  149. if (i == OK)
  150. printf("队头元素是:%d\n", d);
  151. DeQueue(&q, &d);
  152. printf("删除了队头元素%d\n", d);
  153. i = GetHead(q, &d);
  154. if (i == OK)
  155. printf("新的队头元素是:%d\n", d);
  156. ClearQueue(&q);
  157. printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n", q.front, q.rear, q.front->next);
  158. DestroyQueue(&q);
  159. printf("销毁队列后,q.front=%u q.rear=%u\n", q.front, q.rear);
  160. return 0;
  161. }

来自为知笔记(Wiz)

时间: 2024-11-03 22:39:50

链式队列的相关文章

数据结构Java实现07----队列:顺序队列&顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo

【数据结构-队列】链式队列

关于链式队列 链式队列又称为链队,是使用单链表实现的,需要一个头指针一个尾指针 结构图: 链队需要的元素组成 /*链式队列的每一个节点*/ struct node{ int data;//存储数据 struct node *next;//指向下一个节点的指针 }; /*链式队列*/ typedef struct{ struct node *head;//头指针 struct node *tail;//尾指针 }LinkedQueue; 创建一个带头节点的空队列 创建一个节点p 将p节点的next

有序链式队列

  编写头文件 struct queue { int num;            //代表数据 int high;           //优先级1111 struct queue *pNext;//存储下一个节点的地址 }; typedef  struct queue Queue;                           //简化队列 Queue * init(Queue *queueHead);                        //初始化 Queue *

C++链式队列

LinkQueue: //链式队列 #include<iostream> using namespace std; typedef int elemType; struct QNode { elemType data; QNode *next; }; struct LinkQueue { QNode *front; QNode *rear; }; //初始化 void InitQueue(LinkQueue *q) { q->front = q->rear = new QNode;

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

链式队列的实现

链式队列数据结构如下: typedef struct qnode{ ElemType data; struct qnode* next; //指向下一节点指针 }QNode; typedef struct{ QNode* front; //队首指针 QNode* rear; //队尾指针 }ListQueue; 实现以下函数: void InitQueue(ListQueue* &q); //初始化队列 void ClearQueue(ListQueue* &q); //清空队列 int

不带头结点的链式队列进出队操作

/* 不带头结点的链式队列进出队操作 */ #include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct QNode *Queue; typedef struct Node{ ElementType Data; struct Node *Next; }; typedef struct QNode{ struct Node *front; struct Node *rear; }; void

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

链式队列总结

基本数据结构之-链式队列 链式队列就是一个操作受到限制的单链表,学会了单链表再来写这个就是轻松加愉快,但是貌似我去用了两个小时搞定,主要是基础差! 队列的基本操作就是入栈和出栈,还可以看到对头和对尾 如果维护了长度参数,那么也可以返回一个长度 不说理论了,直接上代码吧! 首先定义基本数据结构的结构体: typedef struct _LINKQUEUENODE { struct _LINKQUEUENODE *next; }LinkQueueNode; typedef struct _LINKQ