队列实验报告
顺序循环队列实验报告

一、实验目的1. 理解顺序循环队列的概念和原理。
2. 掌握顺序循环队列的初始化、入队、出队等基本操作。
3. 通过编程实现顺序循环队列,并验证其功能。
二、实验原理顺序循环队列是一种利用一维数组实现队列的存储结构。
它将一维数组看作是首尾相连的循环结构,队列的头部和尾部在数组的两端。
顺序循环队列的特点是:队列满时,头指针和尾指针相差一个数组的长度;队列空时,头指针和尾指针相等。
顺序循环队列的基本操作如下:1. 初始化:创建一个顺序循环队列,并设置头指针和尾指针。
2. 入队:将元素插入队列尾部。
3. 出队:从队列头部删除元素。
4. 判断队列是否为空或满。
三、实验内容1. 创建顺序循环队列类。
2. 实现顺序循环队列的初始化、入队、出队等基本操作。
3. 编写测试代码,验证顺序循环队列的功能。
四、实验步骤1. 创建顺序循环队列类,定义队列长度、头指针、尾指针等属性。
2. 实现顺序循环队列的初始化方法,初始化头指针和尾指针。
3. 实现顺序循环队列的入队方法,判断队列是否已满,如果未满,将元素插入队列尾部,并更新尾指针;如果已满,则提示队列已满。
4. 实现顺序循环队列的出队方法,判断队列是否为空,如果为空,则提示队列已空;如果未空,则从队列头部删除元素,并更新头指针。
5. 编写测试代码,创建顺序循环队列实例,执行入队和出队操作,验证顺序循环队列的功能。
五、实验结果与分析1. 初始化顺序循环队列```pythonclass CircularQueue:def __init__(self, size):self.queue = [None] sizeself.head = 0self.tail = 0self.count = 0self.maxsize = size```2. 入队操作```pythondef enqueue(self, item):if self.count == self.maxsize:print("Queue is full")else:self.queue[self.tail] = itemself.tail = (self.tail + 1) % self.maxsizeself.count += 1```3. 出队操作```pythondef dequeue(self):if self.count == 0:print("Queue is empty")else:item = self.queue[self.head]self.queue[self.head] = Noneself.head = (self.head + 1) % self.maxsize self.count -= 1return item```4. 测试代码```pythondef test_circular_queue():queue = CircularQueue(5)print("Enqueue 1 to 5:")for i in range(1, 6):queue.enqueue(i)print(queue.queue)print("Dequeue 1 to 5:")for _ in range(5):print(queue.dequeue())print(queue.queue)test_circular_queue()```实验结果分析:通过测试代码,我们可以看到顺序循环队列在初始化、入队和出队操作时都能正确执行。
队列实验报告

1. 了解队列实验的基本概念和设计方法。
2. 掌握队列实验数据的收集和分析方法。
3. 通过实际操作,提高对队列实验的理解和应用能力。
二、实验背景队列实验是一种观察性研究方法,通过对一组人群进行长期追踪观察,以研究某种因素与疾病发生之间的关系。
与临床试验相比,队列实验不受随机分配的影响,更能反映实际情况。
本实验以某地区居民为研究对象,旨在探究某种生活习惯与慢性病发病风险之间的关系。
三、实验方法1. 研究对象:选取某地区1000名居民作为研究对象,年龄在40-70岁之间,性别不限。
2. 数据收集:采用问卷调查和临床检查相结合的方式收集数据。
问卷调查内容包括:年龄、性别、职业、生活习惯、慢性病家族史等;临床检查内容包括:血压、血糖、血脂等生化指标。
3. 数据处理:将收集到的数据进行整理、分类,并录入数据库。
4. 实验分组:根据生活习惯将研究对象分为两组,即暴露组和非暴露组。
5. 统计分析:采用卡方检验、Logistic回归等方法分析两组人群慢性病发病风险差异。
四、实验结果1. 暴露组和非暴露组的基本特征:两组在年龄、性别、职业等方面无显著差异(P>0.05)。
2. 慢性病发病风险:暴露组慢性病发病率为30%,非暴露组慢性病发病率为20%。
经卡方检验,两组慢性病发病率存在显著差异(P<0.05)。
3. Logistic回归分析:以慢性病发病为因变量,生活习惯、年龄、性别等变量为自变量,进行Logistic回归分析。
结果显示,生活习惯对慢性病发病有显著影响(P<0.05)。
1. 队列实验作为一种观察性研究方法,在慢性病研究领域具有重要意义。
本实验通过观察生活习惯与慢性病发病风险之间的关系,为慢性病预防提供了依据。
2. 实验结果显示,生活习惯对慢性病发病有显著影响。
这提示我们在日常生活中,要养成良好的生活习惯,降低慢性病发病风险。
3. 本实验样本量较大,研究结论具有一定的代表性。
但本研究仍存在一些局限性,如地域局限性、样本量等。
【推荐】队列操作实验报告-word范文模板 (12页)

本文部分内容来自网络整理,本司不为其真实性负责,如有异议或侵权请及时联系,本司将立即删除!== 本文为word格式,下载后可方便编辑和修改! ==队列操作实验报告篇一:栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(2学时,验证型),掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】验证性实验(学时数:2H)【实验内容】内容:把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用,如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【实验分析、说明过程】【思考问题】【实验小结】 ( 总结本次实验的重难点及心得、体会、收获)【附录-实验代码】篇二:队列存储与操作实验报告实验四队列存储与操作一. 实验目的1、掌握队列顺序存储结构(循环队列)及实现及操作2、掌握队列的链接存储结构及实现及操作二. 实验内容1、建立一个空顺序存储结构队列;对已建立的队列进行插入、删除、取队头元素等基本操作。
2、建立一个空链式存储结构队列;对已建立的队列进行插入、删除、取队头元素等基本操作。
三、详细设计:1、顺序队列的实现:#include<iostream>using namespace std;const int Size=100;typedef char DataType;class CirQueue{public:CirQueue() { } ~CirQueue(){} void EnQueue(DataType x){if((rear+1)%Size==front) {} cout<<"队列已经满了"<<endl; return; front=rear=0;//构造队列,初始化一个空的循环队列,front和rear指向};} data[rear]=x; cout<<x<<"已入队"<<endl; return; DataTypeGetQueue()//取队头 { } DataType DeQueue() { } int isEmpty()//是否为空{ } DataType data[Size]; int front,rear; if(front==rear) { } else{ } return 0; return 1; if(isEmpty()) {} front=(front+1)%Size;//队头指针在循环的意义下加 return data[front]; cout<<"队列为空"<<endl; return 0; if(isEmpty()) {} int i; i=(front+1)%Size; return data[i]; cout<<"队列为空"<<endl; return 0; private:int main(){int index; DataType temp; do{cout<<"**********************************"<<endl; cout<<"1、入队操作"<<endl; cout<<"2、取队头操作"<<endl; cout<<"3、出队操作"<<endl;cout<<"4、判断队列是否为空"<<endl; cout<<"5、退出"<<endl;cout<<"**********************************"<<endl; cin>>index;if(index==5){return 0;} switch(index) { case 1:cout<<"请输入要入队的元素"<<endl; cin>>temp; a.EnQueue(temp); break; temp=a.GetQueue();if(temp!=0) { } cout<<"队头的元素为"<<temp<<" "<<endl;case 2: break; temp=a.DeQueue(); if(temp!=0) { } cout<<"出队的元素为"<<temp<<""<<endl; case 3: break; bool temp; temp=a.isEmpty(); if(temp){cout<<"空队"<<endl; cout<<"非空队"<<endl; }else{ case 4:} } break; }while(index); return 0;2、链队列的实现: #include<iostream> using namespace std;const int Size=100; typedef char DataType; struct Node{};class LinkQueue {public:LinkQueue() { } ~LinkQueue(){} void EnQueue(DataType x) {} DataType GetQueue()//取?队ó头? {if(isEmpty()) {} cout<<"队ó列为a空?"<<endl; return 0; auto s=new Node; s->data=x; s->next=NULL;//申Θ?请?一?个?数簓据Y域?为aX的?结á点?s rear->next=s; rear=s; auto head=new Node; head->next=NULL; front=rear=head; DataType data; Node *next;};} return front->next->data; DataType DeQueue() { } int isEmpty()//是?否?为a空? { } Node*front,*rear;//队ó头?和í队ó尾2指?针?if(front==rear) { } else{ } return 0; return 1; if(isEmpty()) {} auto p=new Node;//用?于?暂Y存?队ó头?元a素? DataType x;//用?于?暂Y存?队ó头?数簓据Y p=front->next; x=p->data; front->next=p->next;if (p->next==NULL) { } delete p; return x; rear=front; cout<<"队ó列为a空?"<<endl; return 0; private:int main() {LinkQueue a; int index; DataType temp; do{cout<<"**********************************"<<endl; cout<<"1、¢入?队ó操ù作痢?<<endl;篇三:队列存储与操作实验报告实验四队列存储与操作一、实验目的1、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,队列顺序存储结构、链式存储结构和循环队列的实现,以便在实际问题背景下灵活运用。
数据队列实验报告总结(3篇)

第1篇一、实验背景数据结构是计算机科学中一个重要的基础学科,其中队列作为一种常用的数据结构,在计算机科学和实际应用中具有广泛的应用。
队列是一种先进先出(FIFO)的线性表,它允许在表的一端进行插入操作,在另一端进行删除操作。
本实验旨在通过实现队列的基本操作,加深对队列数据结构概念和特性的理解,并掌握其在实际应用中的运用。
二、实验目的1. 理解队列数据结构的概念和特性。
2. 掌握队列的存储结构,包括顺序存储和链式存储。
3. 熟悉队列的基本操作,如入队、出队、队列长度、队列状态判断等。
4. 通过实际编程,提高数据结构应用能力。
三、实验内容1. 队列的顺序存储结构实现:- 定义队列结构体,包含队列长度、队列最大长度、队列首尾指针等。
- 实现队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作。
2. 队列的链式存储结构实现:- 定义队列节点结构体,包含队列数据、指针等。
- 实现队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作。
3. 队列的实际应用:- 使用队列实现广度优先搜索(BFS)算法。
- 使用队列实现单链表反转。
- 使用队列实现表达式求值。
四、实验步骤1. 创建队列结构体,定义队列的基本属性和操作函数。
2. 实现队列的顺序存储结构,包括队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作。
3. 实现队列的链式存储结构,包括队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作。
4. 通过实际编程,验证队列的基本操作是否正确。
5. 使用队列实现实际应用,验证队列在解决问题中的应用价值。
五、实验结果与分析1. 顺序存储结构实现:- 队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作均能正常进行。
- 队列的顺序存储结构在插入和删除操作时,需要移动队列中的元素,因此时间复杂度为O(n)。
2. 链式存储结构实现:- 队列的初始化、入队、出队、判断队列是否为空、判断队列是否已满等操作均能正常进行。
顺序队列操作实验报告

一、实验目的1. 理解顺序队列的概念和特点。
2. 掌握顺序队列的创建、插入、删除、遍历等基本操作。
3. 熟悉顺序队列在实际问题中的应用。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 编译器:Visual Studio 2019三、实验内容1. 顺序队列的定义及特点2. 顺序队列的创建3. 顺序队列的插入操作4. 顺序队列的删除操作5. 顺序队列的遍历操作6. 顺序队列的应用四、实验步骤1. 顺序队列的定义及特点顺序队列是一种基于数组的线性数据结构,它具有以下特点:(1)顺序存储:队列元素按照一定的顺序存储在一段连续的内存空间中。
(2)动态扩展:当队列满时,可以动态地增加队列的存储空间。
(3)操作简单:插入和删除操作只需改变队列的头指针和尾指针。
2. 顺序队列的创建首先,定义一个顺序队列的结构体,包括队列的最大容量、队列的当前长度、队列的元素数组等。
然后,实现队列的创建函数,初始化队列的各个属性。
```cpp#include <iostream>using namespace std;#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int front;int rear;} SeqQueue;void InitQueue(SeqQueue &Q) {Q.front = 0;Q.rear = 0;}```3. 顺序队列的插入操作实现队列的插入函数,判断队列是否已满,如果未满,则将新元素插入到队列的尾部。
```cppbool EnQueue(SeqQueue &Q, int x) {if ((Q.rear + 1) % MAX_SIZE == Q.front) {return false; // 队列已满}Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MAX_SIZE;return true;}```4. 顺序队列的删除操作实现队列的删除函数,判断队列是否为空,如果非空,则删除队列的头部元素。
实验报告队列

一、实验目的1. 理解队列的概念和特点;2. 掌握队列的基本操作,包括入队、出队、查看队列头元素等;3. 能够使用队列解决实际问题。
二、实验环境1. 操作系统:Windows 10;2. 编程语言:C语言;3. 开发环境:Visual Studio 2019。
三、实验内容1. 队列的定义和实现;2. 队列的基本操作;3. 使用队列解决实际问题。
四、实验步骤1. 队列的定义和实现(1)定义队列的数据结构```c#define MAXSIZE 100 // 队列的最大容量typedef struct {int data[MAXSIZE]; // 队列的存储空间int front; // 队列头指针int rear; // 队列尾指针} Queue;```(2)初始化队列```cvoid InitQueue(Queue q) {q->front = 0;q->rear = 0;}```(3)判断队列是否为空```cint IsEmpty(Queue q) {return q->front == q->rear;}```(4)判断队列是否已满```cint IsFull(Queue q) {return (q->rear + 1) % MAXSIZE == q->front; }```2. 队列的基本操作(1)入队操作```cint EnQueue(Queue q, int x) {if (IsFull(q)) {return 0; // 队列已满}q->data[q->rear] = x;q->rear = (q->rear + 1) % MAXSIZE; return 1;}```(2)出队操作```cint DeQueue(Queue q, int x) {if (IsEmpty(q)) {return 0; // 队列为空}x = q->data[q->front];q->front = (q->front + 1) % MAXSIZE; return 1;}```(3)查看队列头元素```cint GetHead(Queue q, int x) {if (IsEmpty(q)) {return 0; // 队列为空}x = q->data[q->front];return 1;}```3. 使用队列解决实际问题(1)实现一个简单的函数,将一个整数数组中的元素按照逆序输出```cvoid ReversePrint(int arr[], int n) {Queue q;InitQueue(&q);for (int i = 0; i < n; i++) {EnQueue(&q, arr[i]);}int x;while (!IsEmpty(&q)) {DeQueue(&q, &x);printf("%d ", x);}printf("\n");}```(2)实现一个函数,计算两个整数序列的交集```cvoid Intersection(int arr1[], int n1, int arr2[], int n2, int result[]) {Queue q;InitQueue(&q);for (int i = 0; i < n1; i++) {EnQueue(&q, arr1[i]);}int x;int i = 0, j = 0;while (!IsEmpty(&q)) {DeQueue(&q, &x);while (i < n2 && arr2[i] < x) {i++;}if (i < n2 && arr2[i] == x) {result[j++] = x;}}result[j] = 0; // 标记交集结束}```五、实验结果与分析1. 实验结果(1)定义队列的数据结构(2)初始化队列(3)判断队列是否为空(4)判断队列是否已满(5)入队操作(6)出队操作(7)查看队列头元素(8)使用队列逆序输出整数数组(9)使用队列计算两个整数序列的交集2. 实验分析通过本次实验,我们掌握了队列的基本概念、数据结构、操作方法以及在实际问题中的应用。
【最新】队列操作实验报告-范文word版 (12页)

本文部分内容来自网络整理,本司不为其真实性负责,如有异议或侵权请及时联系,本司将立即删除!== 本文为word格式,下载后可方便编辑和修改! ==队列操作实验报告篇一:栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(2学时,验证型),掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】验证性实验(学时数:2H)【实验内容】内容:把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用,如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【实验分析、说明过程】【思考问题】【实验小结】 ( 总结本次实验的重难点及心得、体会、收获)【附录-实验代码】篇二:队列存储与操作实验报告实验四队列存储与操作一. 实验目的1、掌握队列顺序存储结构(循环队列)及实现及操作2、掌握队列的链接存储结构及实现及操作二. 实验内容1、建立一个空顺序存储结构队列;对已建立的队列进行插入、删除、取队头元素等基本操作。
2、建立一个空链式存储结构队列;对已建立的队列进行插入、删除、取队头元素等基本操作。
三、详细设计:1、顺序队列的实现:#include<iostream>using namespace std;const int Size=100;typedef char DataType;class CirQueue{public:CirQueue() { } ~CirQueue(){} void EnQueue(DataType x){if((rear+1)%Size==front) {} cout<<"队列已经满了"<<endl; return; front=rear=0;//构造队列,初始化一个空的循环队列,front和rear指向};} data[rear]=x; cout<<x<<"已入队"<<endl; return; DataTypeGetQueue()//取队头 { } DataType DeQueue() { } int isEmpty()//是否为空{ } DataType data[Size]; int front,rear; if(front==rear) { } else{ } return 0; return 1; if(isEmpty()) {} front=(front+1)%Size;//队头指针在循环的意义下加 return data[front]; cout<<"队列为空"<<endl; return 0; if(isEmpty()) {} int i; i=(front+1)%Size; return data[i]; cout<<"队列为空"<<endl; return 0; private:int main(){int index; DataType temp; do{cout<<"**********************************"<<endl; cout<<"1、入队操作"<<endl; cout<<"2、取队头操作"<<endl; cout<<"3、出队操作"<<endl;cout<<"4、判断队列是否为空"<<endl; cout<<"5、退出"<<endl;cout<<"**********************************"<<endl; cin>>index;if(index==5){return 0;} switch(index) { case 1:cout<<"请输入要入队的元素"<<endl; cin>>temp; a.EnQueue(temp); break; temp=a.GetQueue();if(temp!=0) { } cout<<"队头的元素为"<<temp<<" "<<endl;case 2: break; temp=a.DeQueue(); if(temp!=0) { } cout<<"出队的元素为"<<temp<<""<<endl; case 3: break; bool temp; temp=a.isEmpty(); if(temp){cout<<"空队"<<endl; cout<<"非空队"<<endl; }else{ case 4:} } break; }while(index); return 0;2、链队列的实现: #include<iostream> using namespace std;const int Size=100; typedef char DataType; struct Node{};class LinkQueue {public:LinkQueue() { } ~LinkQueue(){} void EnQueue(DataType x) {} DataType GetQueue()//取?队ó头? {if(isEmpty()) {} cout<<"队ó列为a空?"<<endl; return 0; auto s=new Node; s->data=x; s->next=NULL;//申Θ?请?一?个?数簓据Y域?为aX的?结á点?s rear->next=s; rear=s; auto head=new Node; head->next=NULL; front=rear=head; DataType data; Node *next;};} return front->next->data; DataType DeQueue() { } int isEmpty()//是?否?为a空? { } Node*front,*rear;//队ó头?和í队ó尾2指?针?if(front==rear) { } else{ } return 0; return 1; if(isEmpty()) {} auto p=new Node;//用?于?暂Y存?队ó头?元a素? DataType x;//用?于?暂Y存?队ó头?数簓据Y p=front->next; x=p->data; front->next=p->next;if (p->next==NULL) { } delete p; return x; rear=front; cout<<"队ó列为a空?"<<endl; return 0; private:int main() {LinkQueue a; int index; DataType temp; do{cout<<"**********************************"<<endl; cout<<"1、¢入?队ó操ù作痢?<<endl;篇三:队列存储与操作实验报告实验四队列存储与操作一、实验目的1、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,队列顺序存储结构、链式存储结构和循环队列的实现,以便在实际问题背景下灵活运用。
队列验证实验报告

一、实验目的1. 理解队列的概念和作用。
2. 掌握队列的创建、插入、删除和遍历等基本操作。
3. 验证队列在实际应用中的正确性和效率。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验内容1. 队列的创建与初始化2. 队列的插入操作3. 队列的删除操作4. 队列的遍历操作5. 队列的应用实例四、实验步骤1. 队列的创建与初始化(1)定义一个队列类,包含队列的基本属性和方法。
(2)初始化队列,设置队列的最大容量。
(3)实现队列的入队和出队操作。
2. 队列的插入操作(1)实现队列的入队操作,即向队列中添加元素。
(2)在插入元素时,判断队列是否已满,若已满则抛出异常。
3. 队列的删除操作(1)实现队列的出队操作,即从队列中移除元素。
(2)在删除元素时,判断队列是否为空,若为空则抛出异常。
4. 队列的遍历操作(1)实现队列的遍历操作,即输出队列中的所有元素。
(2)在遍历时,保持队列的顺序不变。
5. 队列的应用实例(1)模拟银行排队取款场景,实现队列的基本操作。
(2)分析队列在实际应用中的优点和缺点。
五、实验结果与分析1. 队列的创建与初始化(1)创建一个队列对象,设置最大容量为5。
(2)初始化队列,添加元素1、2、3、4、5。
2. 队列的插入操作(1)向队列中插入元素6,队列状态为[1, 2, 3, 4, 5, 6]。
(2)队列已满,尝试插入元素7时,抛出异常。
3. 队列的删除操作(1)从队列中删除元素1,队列状态为[2, 3, 4, 5, 6]。
(2)队列已空,尝试删除元素时,抛出异常。
4. 队列的遍历操作(1)遍历队列,输出元素为[2, 3, 4, 5, 6]。
(2)遍历过程中,队列顺序不变。
5. 队列的应用实例(1)模拟银行排队取款场景,实现队列的基本操作。
(2)分析队列在实际应用中的优点和缺点。
六、实验结论1. 队列是一种先进先出(FIFO)的数据结构,适用于处理按顺序处理任务的情况。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一.实验项目名称
循环队列和链式队列的创建
二、实验目的
1、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,
2、队列顺序存储结构、链式存储结构和循环队列的实现,以便在
实际问题背景下灵活应用。
三、实验内容
1.链式队列的实现和运算
2.循环队列的实现和运算
四、主要仪器设备及耗材
VC++6.0运行环境实现其操作
五.程序算法
(1) 循环队列操作的算法
1>进队列
V oid enqueue (seqqueue &q, elemtype x)
{
if ((q.rear+1)%maxsize = = q.front)
cout<<”overflow”;
else {
q.rear=(q.rear+1)%maxsize; //编号加1或循环回第一个单元
q.queue[q.rear]=x;
}
}
2>出队列
V oid dlqueue(seqqueue &q )
{
if (q.rear= =q.front) cout<<”underflow”;
else
q.front =(q.front+1)%maxsize;
}
3>取对头元素
elemtype gethead(seqqueue q )
{ if (q.rear= =q.front)
{ cout<<”underflow”;
return NULL;}
else return q.queue[(q.front+1)%maxsize];
//front指向队头前一个位置
}
4>判队列空否
int empty(seqqueue q )
{
if (q.rear= =q.front) reurn 1;
else return 0;
}
(2).链队列操作的算法
1>.链队列上的初始化
void INIQUEUE( linkqueue &s)
{ link *p;
p=new link;
p->next=NULL; //p是结构体指针类型,用->
s.front=p; //s是结构体变量,用.
s.rear=p; //头尾指针都指向头结点
}
2>.入队列
void push(linkqueue &s, elemtype x)
{
link *p; //p是结构体指针类型,用->
p=new link;
p->data=x;
p->next=s.rear->next; //s是结构体变量,用.
s.rear->next=p;
s.rear=p; //插入最后
}
3>判队空
int empty( linkqueue s )
{ if (s.front= =s.rear) return 1;
else return 0;
}
4>.取队头元素
elemtype gethead( linkqueue s )
{
if (s.front= =s.rear) return NULL;
else retuen s.front->next->data;
}
5>.出队列
void pop(linkqueue &s)
{ link *p;
p=s.front->next;
if (p->next= =NULL)//链队列中只有一个元素,需要修改rear指针{ s.front->next=NULL;
s.rear=s.front;}
else
s.front->next =p->next;//rear不用变
delete (p);
}
六.程序源代码
a.循环队列源代码
#include<iostream.h>
#define MAXN 20
struct seq
{
char queue[MAXN];
int front , rear;
};
void iniq(seq &q)
{
q.front=q.rear=MAXN-1;
}
void enq(seq &q,char x)
{
if((q.rear+1)%MAXN==q.front)
cout<<"overflow";
else {
q.rear=(q.rear+1)%MAXN;
q.queue[q.rear]=x;
}
//return(0);
}
void dlq(seq &q)
{
if (q.rear == q.front)
cout<<"underflow";
else
q.front=(q.front+1)%MAXN;
}
int gethead(seq &q) //取队头元素
{if (q.rear == q.front) //判断是否队列为空
cout<<"underflow";
else
return q.queue[(q.front+1)%MAXN];
}
main()
{seq q;
int i,y;
iniq(q);
cout<<"输入元素入队0为止"<<endl;
cin>>i;
while(i)
{
enq( q,i);
cin>>i;
}
y=gethead( q);
cout<<"队头为="<<y<<endl;
dlq( q);
y=gethead( q);
cout<<"执行一次删除队头后,队头为="<<y<<endl;
}
b.链队列的源代码
#include <iostream.h>
typedef struct QNode
{
char data;
QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
InitQueue(LinkQueue &Q)
{
Q.front=Q.rear=new QNode;
Q.front->next=NULL;
return 0;
}
EnQueue(LinkQueue &Q,char e) {
QueuePtr p;
p=new QNode;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return 0;
}
void disp(LinkQueue &Q) //打印队列{
QueuePtr p;
p=Q.front->next;
while(p!=NULL)
{
cout<<p->data<<"->";
p=p->next;
}
}
DeQueue(LinkQueue &Q,char &e) {
QueuePtr p;
if(Q.front==Q.rear)return 1;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
delete p;
return 0;
}
void main()
{
LinkQueue Q;
char e,e1;
InitQueue(Q);
cout<<"输入队列元素,0时结束:"<<endl;
cin>>e;
while(e!='0'){
EnQueue(Q,e);
cin>>e;
}
cout<<"队列为:"<<endl;
disp(Q);
DeQueue(Q,e1);
cout<<endl<<"执行一次删除队头,删除的元素是:"<<e1<<endl;
cout<<"队列为:"<<endl;
disp(Q);
cout<<endl;
}
六.程序输入数据及实验结果
a.循环队列实验结果
c.链队列实验结果
七、思考讨论题或体会或对改进实验的建议
(1)体会
a.C++语言知识不懂,需要好好学习;
b.对单链表不够熟悉,要多练习创建单链表及其基本操作。
八、参考资料
a.《数据结构》李根强主编中国国水利水电出版社
b.《C++语言程序设计》郑莉董渊何江舟编清华大学出版社。