数据结构--顺序循环队列和链式队列

第一部分:顺序循环队列的实现

 1 //循环队列的实现
 2 #define OK 1
 3 #define MAXSIZE_Q 10
 4 //#define OVERFLOW -2
 5 #define ERROR 0
 6
 7 typedef int Status;
 8 typedef int QElemtype;
 9
10 typedef struct{
11     QElemtype *base;  //初始化的动态分配存储空间
12     int front; //队头指针
13     int rear;  //队尾指针
14
15 }SqQueue;
16
17 //---------------------循环队列的基本操作的算法描述-----------------------------
18 Status InitQueue(SqQueue *q)
19 {
20     //构造一个空队列Q
21     q->base=(QElemtype*)malloc(MAXSIZE_Q*sizeof(QElemtype));
22     if(!q->base) exit(-1); //存储分配失败
23     q->front=q->rear=NULL;
24     return OK;
25 }
26
27 int queueLength(SqQueue q)
28 {
29     //返回Q的元素个数,队列的长度
30     return (q.rear-q.front+MAXSIZE_Q)%MAXSIZE_Q;
31 }
32
33 bool isFull(SqQueue *q)
34 {
35     if(q->front=(q->rear+1)%MAXSIZE_Q)
36         return true;
37     return false;
38 }
39
40 bool isEmpty(SqQueue *q)
41 {
42     if(q->front==q->rear)
43         return true;
44     return false;
45 }
46
47 Status EnQueue(SqQueue *q,QElemtype e)
48 {
49     //插入元素e为Q的新的队尾元素
50     if ((q->rear+1)%MAXSIZE_Q==q->front)
51     {
52         //队列满,不进行任何操作,不能再入队
53         return ERROR;
54     }
55     q->base[q->rear]=e;
56     //入队的操作
57     q->rear=(q->rear+1)%MAXSIZE_Q;
58     return OK;
59 }
60
61 Status DeQueue(SqQueue *q,QElemtype *e)
62 {
63     //若队列不空,则删除Q的队头元素,用e返回值,并返回ok,否则返回error
64     if(q->rear==q->front) return ERROR;  //队列满
65     *e=q->base[q->front];  //找到删除的队头元素
66     q->front=(q->front+1)%MAXSIZE_Q;
67     return OK;
68
69 }
70
71 void displayQueue(SqQueue *q)
72 {
73     if (q->front==q->rear)
74     {
75         printf("队列已满\n");
76     }
77     else{
78         //遍历队列
79         int front=q->front;
80         int rear=q->rear;
81         while(front!=rear)
82         {
83             printf("%d\n",q->base[front]);
84             front++;
85         }
86     }
87 }

测试用例

 1 int main()
 2 {
 3     SqQueue q;
 4     InitQueue(&q);
 5     int i;
 6     for(i=0;i<11;i++){
 7         if(EnQueue(&q,i)==ERROR){
 8             printf("循环队列已满,该队列长度为9 \n");
 9         }
10     }
11     printf("the length of queue is %d \n",queueLength(q)); //the length of queue is 9
12     int e1,e2,e3,e4,e5;
13     DeQueue(&q,&e1);
14     DeQueue(&q,&e2);
15     DeQueue(&q,&e3);
16     DeQueue(&q,&e4);
17     DeQueue(&q,&e5);
18     printf("%d--%d--%d--%d--%d \n",e1,e2,e3,e4,e5);
19     printf("the length of queue is %d \n",queueLength(q));
20     printf("循环队列的遍历\n");
21     displayQueue(&q);
22     int e6;
23     DeQueue(&q,&e6);
24     printf("循环队列的遍历\n");
25     displayQueue(&q);
26     system("pause");
27     return 0;
28 }
时间: 2024-10-16 08:49:38

数据结构--顺序循环队列和链式队列的相关文章

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

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

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

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

队列(链式队列)

链式队列----用链表实现,链式队列就是一个操作受限的单向链表,如果读者了解单向链表的建立过程,那理解链式队列就很容易了,先回顾一下单向链表的建立过程 (不熟悉单向链表的可以先看看另一片随笔,再回来看链式队列理解起来更容易?https://www.cnblogs.com/lanhaicode/p/10304567.html) 单向链表 单向链表节点的组成部分 1 struct link 2 { 3 int data; 4 struct link *next; 5 }; 数据域:data----用

数据结构之---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

大话数据结构----循环队列和链式队列

队列(Queue) 是只允许在一端进行插入操作,而在另一端进行删除操作的线性表 队列的特点就是:先进先出,和生活中排队的例子是很先进的,排队的目的不就是先到先得吗. 生活中的队列相当于顺序存储的队列,在火车站排队买票,前面的人买完票走了,后面的人一个一个往前移一位,这是很正常的事情,而计算机中队列队列第一个元素出去了,后面的元素一个一个往前移,这是一件很降低效率的一件事.为了解决这种效率问题,计算机采用循环队列的方式操作队数据. 循环队列 队列的头尾相接的顺序存储结构称为循环队列. 1.首先循环

JAVA实现数组队列,循环数组队列,链式队列

/** * 文件名:QueueText.java * 时间:2014年10月22日下午9:05:13 * 作者:修维康 */ package chapter3; /** * 类名:ArrayQueue * 说明:队列的数组实现 */ class ArrayQueue<AnyType>{ private static final int DEFAULT_CAPACITY = 10; private int front;//队头 private int rear;//队尾 private int

顺序队列和链式队列

#include<iostream> using namespace std; #define ElemType int const int MaxSize=50; typedef struct{ ElemType data[MaxSize]; int front=0,rear=0; }SqQueue; bool EnQueue(SqQueue &Q,ElemType x){ if((Q.rear+1)%MaxSize==Q.front)return false; Q.data[Q.r

c++实验5 顺序/链式队列

链式队列及循环队列 1.循环队列的实现(请采用模板类及模板函数实现) [实现提示] 同时可参见教材p65-p67页的ADT描述及算法实现及ppt)函数.类名称等可自定义,部分变量请加上学号后3位.也可自行对类中所定义的操作进行扩展. 所加载的库函数或常量定义及类的定义: #include<stdlib.h> #include<iostream> using namespace std; typedef int DataType; class SeqQueue{ private: D