实验三 栈和队列的操作

合集下载

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告实验概述本次实验的目的是通过对栈和队列进行实现和应用,加深对数据结构中的栈和队列的理解和巩固操作技能。

栈和队列作为常见的数据结构在程序开发中得到了广泛的应用,本次实验通过 C++ 语言编写程序,实现了栈和队列的基本操作,并对两种数据结构进行了应用。

实验内容1. 栈的实现栈是一种先进后出的数据结构,具有后进先出的特点。

通过使用数组来实现栈,实现入栈、出栈、输出栈顶元素和清空栈等操作。

对于入栈操作,将元素插入到数组的栈顶位置;对于出栈操作,先将数组的栈顶元素弹出,再使其下移,即将后面的元素全部向上移动一个位置;输出栈顶元素则直接输出数组的栈顶元素;清空栈则将栈中所有元素全部清除即可。

3. 栈和队列的应用利用栈和队列实现八皇后问题的求解。

八皇后问题,是指在8×8 的国际象棋盘上放置八个皇后,使得任意两个皇后都不能在同一行、同一列或者同一对角线上。

通过使用栈来保存当前八皇后的位置,逐个放置皇后并检查是否有冲突。

如果当前位置符合要求,则将位置保存到栈中,并继续查询下一个皇后的位置。

通过使用队列来进行八数码问题的求解。

八数码问题,是指在3×3 的矩阵中给出 1 至 8 的数字和一个空格,通过移动数字,最终将其变为 1 2 3 4 5 6 7 8 空的排列。

通过使用队列,从初始状态出发,枚举每种情况,利用队列进行广度遍历,逐一枚举状态转移,找到对应的状态后进行更新,周而复始直到找到正确的答案。

实验结果通过使用 C++ 语言编写程序,实现了栈和队列的基本操作,并对八皇后和八数码问题进行了求解。

程序执行结果如下:栈和队列实现的基本操作都能够正常进行,并且运行效率较高。

栈和队列的实现方便了程序编写并加速了程序运行。

2. 八皇后问题的求解通过使用栈来求解八皇后问题,可以得到一组成立的解集。

图中展示了求解某一种八皇后问题的过程。

从左到右是棋盘的列数,从上到下是棋盘的行数,通过栈的操作,求出了在棋盘上符合不同要求(不在同一行、同一列和斜线上)的八皇后位置。

数据结构栈和队列实验报告

数据结构栈和队列实验报告

数据结构栈和队列实验报告数据结构栈和队列实验报告1.实验目的本实验旨在通过设计栈和队列的数据结构,加深对栈和队列的理解,并通过实际操作进一步掌握它们的基本操作及应用。

2.实验内容2.1 栈的实现在本实验中,我们将使用数组和链表两种方式实现栈。

我们将分别实现栈的初始化、入栈、出栈、判断栈是否为空以及获取栈顶元素等基本操作。

通过对这些操作的实现,我们可将其用于解决实际问题中。

2.2 队列的实现同样地,我们将使用数组和链表两种方式实现队列。

我们将实现队列的初始化、入队、出队、判断队列是否为空以及获取队头元素等基本操作。

通过对这些操作的实现,我们可进一步了解队列的特性,并掌握队列在实际问题中的应用。

3.实验步骤3.1 栈的实现步骤3.1.1 数组实现栈(详细介绍数组实现栈的具体步骤)3.1.2 链表实现栈(详细介绍链表实现栈的具体步骤)3.2 队列的实现步骤3.2.1 数组实现队列(详细介绍数组实现队列的具体步骤)3.2.2 链表实现队列(详细介绍链表实现队列的具体步骤)4.实验结果与分析4.1 栈实验结果分析(分析使用数组和链表实现栈的优缺点,以及实际应用场景)4.2 队列实验结果分析(分析使用数组和链表实现队列的优缺点,以及实际应用场景)5.实验总结通过本次实验,我们深入了解了栈和队列这两种基本的数据结构,并利用它们解决了一些实际问题。

我们通过对数组和链表两种方式的实现,进一步加深了对栈和队列的理解。

通过实验的操作过程,我们也学会了如何设计和实现基本的数据结构,这对我们在日后的学习和工作中都具有重要意义。

6.附件6.1 源代码(附上栈和队列的实现代码)6.2 实验报告相关数据(附上实验过程中所产生的数据)7.法律名词及注释7.1 栈栈指的是一种存储数据的线性数据结构,具有后进先出(LIFO)的特点。

栈的操作主要包括入栈和出栈。

7.2 队列队列指的是一种存储数据的线性数据结构,具有先进先出(FIFO)的特点。

栈和队列的操作实验小结

栈和队列的操作实验小结

栈和队列的操作实验小结一、实验目的本次实验旨在深入理解和掌握栈和队列这两种基本数据结构的基本操作,包括插入、删除、查找等操作,并通过实际操作加深对这两种数据结构特性的理解。

二、实验原理栈(Stack):栈是一种后进先出(Last In First Out,LIFO)的数据结构,即最后一个进入栈的元素总是第一个出栈。

在计算机程序中,栈常常被用来实现函数调用和递归等操作。

队列(Queue):队列是一种先进先出(First In First Out,FIFO)的数据结构,即第一个进入队列的元素总是第一个出队。

在计算机程序中,队列常常被用来实现任务的调度和缓冲等操作。

三、实验步骤与结果创建一个空栈和一个空队列。

对栈进行入栈(push)和出栈(pop)操作,观察并记录结果。

可以发现,栈的出栈顺序与入栈顺序相反,体现了后进先出的特性。

对队列进行入队(enqueue)和出队(dequeue)操作,观察并记录结果。

可以发现,队列的出队顺序与入队顺序相同,体现了先进先出的特性。

尝试在栈和队列中查找元素,记录查找效率和准确性。

由于栈和队列的特性,查找操作并不像在其他数据结构(如二叉搜索树或哈希表)中那样高效。

四、实验总结与讨论通过本次实验,我更深入地理解了栈和队列这两种数据结构的基本特性和操作。

在实际编程中,我可以根据需求选择合适的数据结构来提高程序的效率。

我注意到,虽然栈和队列在某些操作上可能不如其他数据结构高效(如查找),但它们在某些特定场景下具有无可替代的优势。

例如,在实现函数调用和递归时,栈的特性使得它成为最自然的选择;在实现任务调度和缓冲时,队列的特性使得它成为最佳选择。

我也认识到,不同的数据结构适用于解决不同的问题。

在选择数据结构时,我需要考虑数据的特性、操作的频率以及对时间和空间复杂度的需求等因素。

通过实际操作,我对栈和队列的实现方式有了更深入的理解。

例如,我了解到栈可以通过数组或链表来实现,而队列则可以通过链表或循环数组来实现。

实验三栈和队列的操作

实验三栈和队列的操作

实验三栈和队列的操作实验三栈和队列的操作一.实验目的和要求1、学会通过对问题的分析,设计一种合理的数据结构,并进行定义及操作的实现。

2、掌握利用栈和队列的各种操作来进行具体的实际应用。

3、加强综合程序的分析、设计能力。

二.实验内容课后习题4-7三.实验步骤1、定义一个函数void QInsert(LNode*&Rear,const ElemType& item),新建一个结点,如果尾指针为空,则指向新建的结点;否则新结点指向尾指针当前指向的结点,然后尾指针指向新结点,最后新结点成为尾指针。

2、定义一个函数ElemType QDelete(LNode*&Rear),若删除的是最后一个结点,则删除后尾指针为NULL,尾指针指向被删除结点的后继。

3、定义函数void Print(LNode*&Rear)输出队列,从第一个结点开始依次输出,第一个结点就是尾指针指向的结点。

注意:定义文件后缀为.cpp,头文件为四.附源程序#include#includetypedef int ElemType;struct LNode{LNode *next;ElemType data;};void QInsert(LNode*&Rear,const ElemType& item) //使新元素item的值插入到循环链队中{LNode*newptr=new LNode;//得到一个由newptr指针所指向的新结点if(newptr==NULL){cerr<<"Memory allocation failare"<<endl;< p=""> exit(1);}newptr->data=item;//把item的值赋给新结点的值域if(Rear==NULL)Rear=newptr->next=newptr;//若链队为空,则新结点即是队首结点又是队尾结点else{newptr->next=Rear->next;//使新结点的指针域指向队首结点Rear->next=newptr;//使队尾结点的指针域指向新结点Rear=newptr;//使新结点成为新的队尾结点}}ElemType QDelete(LNode*&Rear)//从循环链队中删除队首元素{if(Rear==NULL){cerr<<"Linked queue is empty!"<<endl;< p=""> exit(1);}LNode* p=Rear->next; //使p指向队首结点if(p==Rear)Rear=NULL;//若链队中只有一个结点,则删除后队尾指针为空elseRear->next=p->next;//使队尾结点的指针域指向队首结点的后继结点ElemType temp=p->data;//暂存队首元素delete p;//回收原队首结点return temp;//返回被删除的队首元素}void Print(LNode*&Rear){LNode* q=Rear->next;//从第一个结点开始while(q!=Rear)//只要不是最后一个结点{cout<data<<' ';//输出该结点的值q=q->next;//指针往后移}cout<data<<="">}void main(){LNode* L1=NULL;QInsert(L1,3);QInsert(L1,5);QInsert(L1,9);QInsert(L1,1);QInsert(L1,6);QInsert(L1,2);Print(L1);QInsert(L1,12); QDelete(L1); QDelete(L1); QDelete(L1); QInsert(L1,19); Print(L1);}</endl;<></endl;<>。

实验三栈和队列

实验三栈和队列

《数据结构》课程实验实验报告三第三章栈和队列的操作实验题目:实验三栈和队列的操作学号:******** 班级:计算机111 姓名:张婷指导教师:**实验完成时间:2013.4.22实验成绩:实验三栈和队列的操作一、实验学时 2学时二、背景知识1.栈:(1).入栈和进栈操作只能从栈顶一端进行;(2).LIFO(后进先出);(3).栈的两种存储定义:顺序栈和链式栈。

2.队列:(1).入队操作从队尾进行,出队操作从对头进行;(2).FIFO(先进先出);(3).队列的两种存储定义:顺序队和链队。

三、目的要求1.掌握栈的顺序表示和实现。

Typedef struct{SelemType *base;SelemType *base;Int stacksize;}sqstack;2.掌握队列的链式表示和实现以及顺序表示和实现。

链队列:Typedef struct Qnode{QelemType data;struct Qnode *next;} Qnode,*Queueptr;Typedef struct{Queueptr front;Queueptr rear;}linkQueue;顺序队列:#define MAXQSIZE 100Typedef struct{Qelemtype *base;int front;int rear;}sqQueue;四、实验内容1.顺序栈和循环队列的创建、入栈(队)、出栈(队)等基本操作。

2.数制转换问题【问题描述】十进制数N和其它d进制数的转换是计算机实现计算的基本问题。

试编制一段程序满足下列要求:对于输入的任意一个非负十进制整数,打印输出与其等值的八进制数。

【基本要求】首先初始化一个顺序栈,通过入栈出栈操作辅助完成数制的转换操作。

五、程序实例:顺序队列的入队和出队操作。

【问题描述】使有数组创建队列。

程序使有选项运行队列的操作,如:输入1表示元素入队,输入2表示元素出队,输入3表示结束程序运行,并且将队列剩余元素输出。

湖北理工(黄石理工)数据结构实验 实验三栈、队列的实现及应用一

湖北理工(黄石理工)数据结构实验 实验三栈、队列的实现及应用一

实验报告实验课程名称数据结构班级09计科(1)班实验项目名称实验三栈、队列的实现及应用指导老师祁文青姓名*** 学号**评分实验地点K4-206 实验日期一、实验目的和要求1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际背景下灵活运用。

2、掌握栈和队列的特点,即先进后出与先进先出的原则。

3、掌握栈和队列的基本操作实现方法。

12二、实验内容任务1:实现栈的顺序存储和链式存储#include "stdio.h"#include "stdlib.h"#include "malloc.h"#include "iostream.h"# define STACK_INIT_SIZE 100# define STACKINCREMENT 10# define MAXQSIZE 100# define OK 1# define ERROR 0typedef int SElemType;typedef struct{ SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S){ S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base){ cout<<endl<<"Allocate space failure !";return (ERROR);} S.top=S.base;S.stacksize=STACK_INIT_SIZE; return (OK);三、结论1、掌握了栈和队列的顺序存储结构和链式存储结构,2、掌握栈和队列的特点,即先进后出与先进先出的原则,掌握栈和队列的基本操作实现方法。

数据结构_实验三_栈和队列及其应用(可编辑

数据结构_实验三_栈和队列及其应用(可编辑

数据结构_实验三_栈和队列及其应用(可编辑实验三:栈和队列及其应用1.实验目的:1.1掌握栈和队列的定义与基本操作。

1.2理解栈和队列的应用场景。

1.3熟悉栈和队列在计算机程序设计中的应用。

2.实验内容:2.1实现栈数据结构的基本操作:初始化、入栈、出栈、判断栈空、判断栈满、获取栈顶元素。

2.2实现队列数据结构的基本操作:初始化、入队、出队、判断队空、判断队满、获取队头元素。

2.3利用栈实现表达式求值。

2.4 利用队列解决Josephus问题。

3.实验步骤:3.1栈的实现:栈(Stack)是一种后进先出(LIFO)的数据结构,只能在一端进行插入和删除操作。

栈的实现可以使用数组或链表,这里以数组为例。

1)初始化栈:创建一个数组,设定一个栈指针top,初始时top值为-12)入栈操作:栈不满时,将元素插入到数组的top+1位置,然后top值加13)出栈操作:栈不空时,将数组的top位置的元素删除,然后top 值减14)判断栈空:当栈指针top为-1时,表示栈空。

5)判断栈满:当栈指针top达到数组的最大索引值时,表示栈满。

6)获取栈顶元素:栈不空时,返回数组的top位置的元素。

3.2队列的实现:队列(Queue)是一种先进先出(FIFO)的数据结构,插入操作在队尾进行,删除操作在队头进行。

队列的实现可以使用数组或链表,这里以数组为例。

1)初始化队列:创建一个数组,设定两个指针front和rear,初始时front和rear值均为-12)入队操作:队列不满时,将元素插入到数组的rear+1位置,然后rear值加13)出队操作:队列不空时,将数组的front+1位置的元素删除,然后front值加14)判断队空:当front和rear指针相等且都为-1时,表示队空。

5)判断队满:当rear指针达到数组的最大索引值时,表示队满。

6)获取队头元素:队列不空时,返回数组的front+1位置的元素。

3.3表达式求值:使用栈可以实现对表达式的求值。

实验三栈和队列的应用

实验三栈和队列的应用

实验三栈和队列的应用第一篇:实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点;掌握栈的顺序存储结构的特点及算法描述;掌握队列的数据类型描述及链式存储结构的特点和算法描述。

二、实验内容停车场管理。

设有一个可以停放n辆汽车的狭长停车场(先进后出),它只有一个大门可以供车辆进出。

车辆按到达停车场时间的先后依次从停车场最里面向大95E8口处停放(最先到达的第一辆车停放在停车场的最里面)。

如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车离开,则排在便道上的第一辆车就可以进入停车场。

停车场内如有某辆车要离开,在它之后进入停车场的车都必须先退出停车场为它让路,待其开出停车场后,这些车再按原来的次序进停车场。

每辆车在离开停车场时,都应根据它在停车场内停留的时间长短交费。

如果停留在便道上的车没进停车场就要离开,允许其离开,不收停车费,并且仍然保持在便道上的车辆次序。

试编程模拟停车场管理。

三、算法描述提示:可以将停车场定义成一个顺序栈s1,便道定义成一个链队列q,而停车场中的某辆车要离开,则在它后面进停车场的车必须让道,让其离开,故还必须有一个临时的顺序栈s2,存放让道的车辆。

当有车辆进停车场时,直接进入s1栈,若s1栈满,则进入便道(链队列q)。

若有s1中车辆x离开时,先让在x后面进栈的车从s1退栈并进栈到s2中,让x离开并收取停车费,然后,再把s2中的所有车辆退栈并重新进入s1栈,最后,将链队列q的队头车辆进栈到s1中并删除队头车辆。

若有链队列q(便道)中的车辆y离开时,从链队列中删除该车辆即可,不收停车费。

车辆的数据可以表示为(车辆编号,到达/离开时间)。

四.程序清单: #include using namespace std;const intStackSize=5;class SeqStack { public:SeqStack(){top=-1;} ~SeqStack(){};void Push(int x);void Push2(int x);int *Return();int Pop(int y);int Count();void PrintStack();private: int data[StackSize];int top;};//入栈void SeqStack::Push(int x){ if(top>=StackSize-1)throw“上溢”;for(int i=0;i<=top+1;i++){if(data[i]==x){cout<<“该车牌已经存在!请重新输入: ”;i=-1;cin>>x;} } top++;data[top]=x;} //返回数组地址int *SeqStack::Return(){ return data;} //临时栈void SeqStack::Push2(int x){ top++;data[top]=x;} //输出函数void SeqStack::PrintStack(){ for(int i=0;i<=top;i++)cout<<“位置为”<int SeqStack::Pop(int y){ if(top==-1)throw“下溢”;int x;x=data[top--];if(y==top+2)data[top+1]=123456789;if(top==-1)data[top+1]=123456789;return x;} //数数int SeqStack::Count(){ return top;}//队列struct Node { int data;Node *next;};class LinkQueue { public: LinkQueue();void EnQueue(int x,int *q);void xzDeQueue(int x);int Count();int DeQueue();private: Node *front,*rear;};//构造函数LinkQueue::LinkQueue(){ Node *s=new Node;s->next=NULL;front=rear=s;} //入队void LinkQueue::EnQueue(int x,int *q){ Node *s=new Node;Node *p=new Node;p=front;while(p){if(p->data ==x){cout<<“便道已有该车牌号,请重新输入: ”;cin>>x;for(int i=0;i<5;i++){if(x==q[i]){cout<<“停车场已有该车牌号,请重新输入: ”;cin>>x;i=-1;}}p=front;} p=p->next;} s->data =x;s->next =NULL;rear->next =s;rear=s;} //出队int LinkQueue::DeQueue(){ if(front==rear)throw“便道无车辆”;Node *p=new Node;int x;p=front->next;x=p->data;front->next =p->next;if(p->next ==NULL)rear=front;delete p;return x;} //计算结点数int LinkQueue::Count(){ Node *p=new Node;p=front;int i=0;while(p&&p->next!=NULL){p=p->next;i++;} return i;} //选择性出队void LinkQueue::xzDeQueue(int x){ if(rear==front)throw“便道无车辆”;Node *p=new Node;p=front;int y;int i=0;for(;p->next!=NULL;p=p->next){if(p->next->data ==x)if(p->next->next!=NULL){Node *q=new Node;q=p->next;y=q->data;p->next =q->next;i=1;delete q;cout<<“车牌号为:”<break;}else{Node *q=new Node;q=p->next;y=q->data;p->next =NULL;i=1;delete q;if(front->next==NULL)rear=front;cout<<“车牌号为:”<break;}} if(i==0)cout<<“无车牌号为:”< SeqStack b;//b是作为临时存放车辆的栈LinkQueue c;//c是作为便道的队列cout<<“tttt1.车辆进入”<cout<<“tttt4.便道车辆离开”<int xh1=1;//xh1为菜单最外层的循环控制变量int time[100];//记录各车辆进入停车场的时间int t1=0;//作为车辆对应的时间编号int money=1;while(xh1==1){cout<<“请选择指令: ”;cin>>zl;switch(zl){case 1:try{int n1=a.Count();int n;cout<<“请输入车牌号: ”;cin>>n;if(n1==4){int *Num=a.Return();for(int i=0;i<=4;i++)if(Num[i]==n){cout<<“停车场已有该车牌号,请重新输入!”; cin>>n;i=-1;}int *CarNum=a.Return();c.EnQueue(n,CarNum);cout<<“停车场已满,请在便道等候!”< break;}a.Push(n);cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”; cin>>time[t1];}t1++;}catch(char*s){cout<break;case 2:try{int n2;//离开车辆的编号cout<<“请输入要离开的车的位置: ”; cin>>n2;if(a.Count()+1==0){cout<<“该停车场没有车辆,请选择其他操作!”; break;}elsewhile(n2<1||n2>a.Count()+1){cout<<“请输入1~”<cin>>n2;}int j=a.Count();for(int i=0;i<(j+1-n2);i++)b.Push2(a.Pop(n2));a.Pop(n2);int j2=b.Count();for(int i1=0;i1<=j2;i1++)a.Push(b.Pop(n2));int j3=c.Count();int time1;cout<<“请输入离开时间: ”;cin>>time1;while(time1<0||time1>23){cout<<“请输入正确的时间(0~23时): ”;cin>>time1;}int day=0;if(time1{cout<<“离开时间已小于进入时间!请加上停留天数(天):”;cin>>day;while(day<=0){cout<<“输入的天数必须大于0:”;cin>>day;}}cout<<“您的费用是(元): ”<<(time1-time[n2-1]+24*day)*money<for(int i2=0;i2<(j+1-n2);i2++)time[n2-1+i2]=time[n2+i2];t1--;if(j3!=0){a.Push(c.DeQueue());cout<<“ttt通知: 便道车辆请进入停车场!”<cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”;cin>>time[t1];}t1++;}}catch(char *s){cout<break;case 3:a.PrintStack();break;case 4:int n3;cout<<“请输入离开车辆的车牌号: ”;cin>>n3;try{c.xzDeQueue(n3);}catch(char*s){cout<break;case 5:cout<<“请输入单价: ”;cin>>money;cout<<“修改成功!”<cout<<“当前停车场的费用是:”<break;case 6:xh1=0;break;} } system(“pause”);}心得体会:完成时间:2010-10-30第二篇:实验三栈和队列实验报告三栈和队列班级:姓名:学号:专业:一、实验目的:(1)掌握栈的基本操作的实现方法。

实验三 栈和队列

实验三 栈和队列

实验报告三栈和队列一、实验目的:(1)掌握栈的基本操作的实现方法。

(2)利用栈先进后出的特点,解决一些实际问题。

(3)掌握链式队列及循环队列的基本操作算法。

(4)应用队列先进先出的特点,解决一些实际问题。

二、实验内容:1、使用一个栈,将一个十进制转换成二进制。

粘贴源程序:package Q1;public class SeqStack {public int element[];public int top;public static SeqStack p;public SeqStack(int size){this.element=new int[size];this.top=-1;}public void push(int x){this.top++;this.element[this.top]=x;}public int pop(){return this.top==-1 ? -1: (int)this.element[this.top--];}public int get(){return this.top==-1 ? -1: (int)this.element[this.top];}public static void disp(SeqStack p){int t = -2;while(t!=-1){t=p.pop();if(t!=-1)System.out.printf("%d",t);}}public static void fun(int x){int t;while(x!=1){t=x%2;x=x/2;p.push(t);}if(x==1)p.push(x);}public static void main(String args[]){p=new SeqStack(13);fun(99);disp(p);}}粘贴测试数据及运行结果:2、回文是指正读反读均相同的字符序列,如“acdca”、“dceecd”均是回文,但“book”不是回文。

实验报告——栈和队列的应用

实验报告——栈和队列的应用

实验报告——栈和队列的应用第一篇:实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求:(1)熟练栈和队列的基本操作;(2)能够利用栈与队列进行简单的应用。

一、题目题目1.利用顺序栈和队列,实现一个栈和一个队列,并利用其判断一个字符串是否是回文。

所谓回文,是指从前向后顺读和从后向前倒读都一样的字符串。

例如,a+b&b+a等等。

题目2.假设在周末舞会上,男士们和女士们进入舞厅时,各自排成一队。

跳舞开始时,依次从男队和女队的队头上各出一人配成舞伴。

若两队初始人数不相同,则较长的那一队中未配对者等待下一轮舞曲。

现要求写一算法模拟上述舞伴配对问题,并实现。

题目3.打印机提供的网络共享打印功能采用了缓冲池技术,队列就是实现这个缓冲技术的数据结构支持。

每台打印机具有一个队列(缓冲池),用户提交打印请求被写入到队列尾,当打印机空闲时,系统读取队列中第一个请求,打印并删除之。

请利用队列的先进先出特性,完成打印机网络共享的先来先服务功能。

题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag,以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时,队列状态为“空”还是“满”。

试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。

题目5.利用循环链队列求解约瑟夫环问题。

请大家从本组未讨论过的五道题中选择一道,参照清华邓俊辉老师MOOC视频及课本相关知识,编写相应程序。

选择题目3:打印机提供的网络共享打印功能采用了缓冲池技术,队列就是实现这个缓冲技术的数据结构支持。

二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x){//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空,新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空,在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令,即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数,将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空,为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数,将命令打印并删除}三、程序调试过程中所出现的错误无。

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告

数据结构栈与队列实验报告学院:数学与计算机学院班级:计算机科学与技术姓名:***学号:************实验三栈与队列一、实验目的:(1)熟练掌握栈和队列的结构以及这两种数据结构的特点、栈与队列的基本操作。

(2)能够在两种存储结构上实现栈的基本运算,特别注意栈满和栈空的判断条件及描述方法;(3)熟练掌握链队列和循环队列的基本运算,并特别注意队列满和队列空的判断条件和描述方法;(4)掌握栈的应用;二、实验要求:(1) 给出程序设计的基本思想、原理和算法描述。

(2) 对源程序给出注释。

(3) 记录程序的运行结果,并结合程序进行分析。

三、程序设计的基本思想、原理和算法描述:四、实验内容:1、利用栈的基本操作将一个十进制的正整数转换成R进制数据,并将其转换结果输出。

#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack {int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){ s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;s->top=s->base;s->stacksize=stack_init_size;return 1;}int Push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int *)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int));if(!s->base)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack*s,int e){if(s->top==s->base)return0;e=*--s->top;return e;}int stackempty(sqstack*s){if(s->top==s->base){return1;}else{return0;}}int conversion(sqstack*s){int n,e=0,flag=0;printf("输入要转化的十进制数:\n");scanf("%d",&n);printf("要转化为多少进制:2进制、8进制、16进制填数字!\n"); scanf("%d",&flag);printf("将十进制数%d转化为%d进制是:\n",n,flag);while(n){Push(s,n%flag);n=n/flag;}while(!stackempty(s)){e=Pop(s,e);switch(e){case10:printf("A");break;case11:printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e);}}printf("\n");return 0; }int main(){sqstack s;StackInit(&s);conversion(&s);return 0;}2、回文数判断#include<stdio.h>#include<string.h>#define MAX 50#define FALSE 0#define TURE 1//定义栈typedef struct{char elem[MAX];int top;}SeqStack;//定义循环队列typedef struct{char element[MAX];int front;int rear;}SeqQuene;//初始化栈void InitStack(SeqStack *S){S->top = -1;//构造一个空栈}//入栈int Push(SeqStack *S,char x,int cnt) {if(S->top == cnt-1)return(FALSE);S->top++;S->elem[S->top] = x;return(TURE);}//出栈int Pop(SeqStack * S,char * x){if(S->top == -1)return(FALSE);else{*x = S->elem[S->top];S->top--;return(TURE);}}//初始化队列void InitQuene(SeqQuene *Q){Q->front = Q->rear = 0;}//入队int EnterQuene(SeqQuene *Q,char x,int cnt) {if((Q->rear+1)%(cnt+1) == Q->front)return(FALSE);Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%(cnt+1);return(TURE);}//出队int DeleteQuene(SeqQuene *Q,char *x,int cnt) {if(Q->front == Q->rear)return(FALSE);*x = Q->element[Q->front];Q->front = (Q->front+1)%(cnt+1);return(TURE);}//主函数void main(){int i,cnt,flag;SeqStack s;SeqQuene q;char a[MAX],b[MAX],c[MAX];flag=0;printf("请输入由*结束且小于%d的回文序列:\n",MAX); for(i = 0;i<MAX+1;i++){scanf("%c",&a[i]);if(a[i] == '*')break;}cnt = i;InitStack(&s);InitQuene(&q);for(i = 0;i<cnt;i++){EnterQuene(&q,a[i],cnt);Push(&s,a[i],cnt);}for(i = 0;i<cnt+1;i++){DeleteQuene(&q,&b[i],cnt);printf("%c",b[i]);}printf("\n");for(i = 0;i<cnt+1;i++){Pop(&s,&c[i]);printf("%c",c[i]);}printf("\n");for(i = 0;i<cnt+1;i++){if(b[i] == c[i])flag = 1;else{flag = 0;break;}}if(flag)printf("Right");elseprintf("Wrong");printf("\n"); }五、运行结果。

栈和队列的应用实验报告

栈和队列的应用实验报告

栈和队列的应用实验报告栈和队列的应用实验报告引言:栈和队列是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。

本实验报告旨在探讨栈和队列的基本概念、特性以及它们在实际应用中的具体使用。

一、栈的基本概念和特性栈是一种特殊的数据结构,它遵循“先进后出”的原则。

栈有两个基本操作:压栈(push)和弹栈(pop)。

压栈将元素添加到栈的顶部,弹栈则将栈顶元素移除。

栈还具有一个重要的特性,即它的访问方式是受限的,只能访问栈顶元素。

在实际应用中,栈可以用于实现递归算法、表达式求值、括号匹配等。

例如,在递归算法中,当函数调用自身时,需要将当前状态保存到栈中,以便在递归结束后能够恢复到正确的状态。

另外,栈还可以用于实现浏览器的“后退”功能,每次浏览新页面时,将当前页面的URL压入栈中,当用户点击“后退”按钮时,再从栈中弹出最近访问的URL。

二、队列的基本概念和特性队列是另一种常见的数据结构,它遵循“先进先出”的原则。

队列有两个基本操作:入队(enqueue)和出队(dequeue)。

入队将元素添加到队列的尾部,出队则将队列头部的元素移除。

与栈不同的是,队列可以访问头部和尾部的元素。

在实际应用中,队列经常用于任务调度、消息传递等场景。

例如,在操作系统中,任务调度器使用队列来管理待执行的任务,每当一个任务执行完毕后,从队列中取出下一个任务进行执行。

另外,消息队列也是一种常见的应用,它用于在分布式系统中传递消息,保证消息的顺序性和可靠性。

三、栈和队列在实际应用中的具体使用1. 栈的应用栈在计算机科学中有广泛的应用。

其中一个典型的应用是表达式求值。

当计算机遇到一个复杂的表达式时,需要将其转化为逆波兰表达式,然后使用栈来进行求值。

栈的特性使得它非常适合处理这种情况,可以方便地保存运算符和操作数的顺序,并按照正确的顺序进行计算。

另一个常见的应用是括号匹配。

在编程语言中,括号是一种常见的语法结构,需要保证括号的匹配性。

数据结构栈和队列实验报告

数据结构栈和队列实验报告

数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。

通过编程实现栈和队列的相关操作,加深对其特性的认识,并能够运用栈和队列解决实际问题。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理(一)栈栈(Stack)是一种特殊的线性表,其操作遵循“后进先出”(Last In First Out,LIFO)的原则。

可以将栈想象成一个只有一端开口的容器,元素只能从开口端进出。

入栈操作(Push)将元素添加到栈顶,出栈操作(Pop)则从栈顶移除元素。

(二)队列队列(Queue)也是一种线性表,但其操作遵循“先进先出”(FirstIn First Out,FIFO)的原则。

队列就像是排队买票的队伍,先到的人先接受服务。

入队操作(Enqueue)将元素添加到队列的末尾,出队操作(Dequeue)则从队列的头部移除元素。

四、实验内容(一)栈的实现与操作1、定义一个栈的数据结构,包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。

2、实现入栈(Push)操作,当栈未满时,将元素添加到栈顶,并更新栈顶指针。

3、实现出栈(Pop)操作,当栈不为空时,取出栈顶元素,并更新栈顶指针。

4、实现获取栈顶元素(Top)操作,返回栈顶元素但不进行出栈操作。

5、实现判断栈是否为空(IsEmpty)和判断栈是否已满(IsFull)的操作。

(二)队列的实现与操作1、定义一个队列的数据结构,包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。

2、实现入队(Enqueue)操作,当队列未满时,将元素添加到队尾,并更新队尾指针。

3、实现出队(Dequeue)操作,当队列不为空时,取出队头元素,并更新队头指针。

4、实现获取队头元素(Front)操作,返回队头元素但不进行出队操作。

5、实现判断队列是否为空(IsEmpty)和判断队列是否已满(IsFull)的操作。

栈和队列的应用实验报告

栈和队列的应用实验报告

栈和队列的应用实验报告
《栈和队列的应用实验报告》
一、实验目的
本实验旨在通过实际操作,掌握栈和队列的基本概念、操作及应用,加深对数
据结构的理解和应用能力。

二、实验内容
1. 栈的基本操作:包括入栈、出栈、获取栈顶元素等。

2. 队列的基本操作:包括入队、出队、获取队首元素等。

3. 栈和队列的应用:通过实际案例,探讨栈和队列在实际生活中的应用场景。

三、实验步骤
1. 学习栈和队列的基本概念和操作。

2. 编写栈和队列的基本操作代码,并进行调试验证。

3. 分析并实现栈和队列在实际应用中的案例,如表达式求值、迷宫问题等。

4. 进行实际应用案例的测试和验证。

四、实验结果
1. 成功实现了栈和队列的基本操作,并通过实际案例验证了其正确性和可靠性。

2. 通过栈和队列在实际应用中的案例,加深了对数据结构的理解和应用能力。

五、实验总结
通过本次实验,我深刻理解了栈和队列的基本概念和操作,并掌握了它们在实
际应用中的重要性和作用。

栈和队列作为数据结构中的重要内容,对于解决实
际问题具有重要意义,希望通过不断的实践和学习,能够更加熟练地运用栈和
队列解决实际问题,提高自己的编程能力和应用能力。

六、感想与展望
本次实验让我对栈和队列有了更深入的了解,也让我对数据结构有了更加深刻的认识。

我将继续学习和探索更多的数据结构知识,提高自己的编程能力和解决问题的能力,为将来的学习和工作打下坚实的基础。

同时,我也希望能够将所学知识应用到实际工程中,为社会做出更大的贡献。

栈和队列的基本操作的实现

栈和队列的基本操作的实现

栈和队列的基本操作的实现栈和队列是两种常用的数据结构,它们都是线性表的特殊形式,但在元素的添加和删除方式上有所不同。

本文将详细介绍栈和队列的基本操作以及它们的实现方式。

一、栈的基本操作1.初始化栈:栈可以用数组或链表实现,初始化操作通常是创建一个空的数组或链表,并将栈顶指针指向-12. 入栈(push):将一个元素添加到栈的顶部。

入栈操作需要将栈顶指针加1,并将元素存储在栈顶位置。

3. 出栈(pop):从栈中删除栈顶元素,并返回该元素的值。

出栈操作需要先将栈顶元素弹出,然后将栈顶指针减14. 获取栈顶元素(top):返回栈顶元素的值,但并不删除它。

这个操作只需要返回栈顶指针对应的位置的元素值即可。

5. 判断栈是否为空(isEmpty):检查栈是否为空,即栈顶指针是否指向-1、如果为空,则返回真;否则返回假。

6. 获取栈的大小(size):返回栈中元素的个数,即栈顶指针加1的值。

二、队列的基本操作1.初始化队列:队列可以用数组或链表实现,初始化操作通常是创建一个空的数组或链表,并初始化队头指针和队尾指针为-12. 入队(enqueue):将一个元素添加到队列的尾部。

入队操作需要将队尾指针加1,并将元素存储在队尾位置。

3. 出队(dequeue):从队列中删除队头元素,并返回该元素的值。

出队操作需要将队头元素弹出,然后将队头指针加14. 获取队头元素(front):返回队头元素的值,但并不删除它。

这个操作只需要返回队头指针对应的位置的元素值即可。

5. 判断队列是否为空(isEmpty):检查队列是否为空,即队头指针是否等于队尾指针。

如果为空,则返回真;否则返回假。

6. 获取队列的大小(size):返回队列中元素的个数,即队尾指针减去队头指针的值。

三、栈和队列的实现方式1.数组实现:栈可以使用一维数组来实现,队列可以使用一维数组或循环数组来实现。

数组的优点是访问速度快,但大小固定,添加或删除元素时需要移动其他元素。

实验三栈和队列的操作

实验三栈和队列的操作

实验三:栈和队列的操作
一、实验名称
栈和队列的操作
二、实验内容
分别建立栈和队列,提供插入、删除元素的算法,并进行验证。

要求:要求栈和队列的数据域是字符串或结构型变量,并可以用一些实用程序来验证。

三、需要提交的材料
1. 实验报告
2. 可运行的程序代码
代码可用C、C++、JAVA等语言编写。

3. 测试用例及运行结果
四、提交方式
1. 实验报告需上交手写稿,不可打印。

上交时间为5月28日(星期六)早课。

2. 程序代码、测试用例和运行结果可上交电子稿。

上交时间与实验报告同一天,。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验三栈和队列的操作
一.实验目的和要求
1、学会通过对问题的分析,设计一种合理的数据结构,并进行定义及操作的实现。

2、掌握利用栈和队列的各种操作来进行具体的实际应用。

3、加强综合程序的分析、设计能力。

二.实验内容
课后习题4-7
三.实验步骤
1、定义一个函数void QInsert(LNode*&Rear,const ElemType& item),新建一个结点,如果尾指针为空,则指向新建的结点;否则新结点指向尾指针当前指向的结点,然后尾指针指向新结点,最后新结点成为尾指针。

2、定义一个函数ElemType QDelete(LNode*&Rear),若删除的是最后一个结点,则删除后尾指针为NULL,尾指针指向被删除结点的后继。

3、定义函数void Print(LNode*&Rear)输出队列,从第一个结点开始依次输出,第一个结点就是尾指针指向的结点。

注意:定义文件后缀为.cpp,头文件为<iostream.h>
四.附源程序
#include<iostream.h>
#include<stdlib.h>
typedef int ElemType;
struct LNode
{
LNode *next;
ElemType data;
};
void QInsert(LNode*&Rear,const ElemType& item)
//使新元素item的值插入到循环链队中
{
LNode*newptr=new LNode;
//得到一个由newptr指针所指向的新结点
if(newptr==NULL){
cerr<<"Memory allocation failare"<<endl;
exit(1);
}
newptr->data=item;//把item的值赋给新结点的值域
if(Rear==NULL)
Rear=newptr->next=newptr;
//若链队为空,则新结点即是队首结点又是队尾结点
else{
newptr->next=Rear->next;
//使新结点的指针域指向队首结点
Rear->next=newptr;
//使队尾结点的指针域指向新结点
Rear=newptr;
//使新结点成为新的队尾结点
}
}
ElemType QDelete(LNode*&Rear)
//从循环链队中删除队首元素
{
if(Rear==NULL){
cerr<<"Linked queue is empty!"<<endl;
exit(1);
}
LNode* p=Rear->next; //使p指向队首结点
if(p==Rear)
Rear=NULL;
//若链队中只有一个结点,则删除后队尾指针为空
else
Rear->next=p->next;
//使队尾结点的指针域指向队首结点的后继结点ElemType temp=p->data;//暂存队首元素
delete p;//回收原队首结点
return temp;//返回被删除的队首元素
}
void Print(LNode*&Rear)
{
LNode* q=Rear->next;//从第一个结点开始
while(q!=Rear)//只要不是最后一个结点
{
cout<<q->data<<' ';//输出该结点的值
q=q->next;//指针往后移
}
cout<<q->data<<endl;//输出最后一个结点的值
}
void main()
{
LNode* L1=NULL;
QInsert(L1,3);
QInsert(L1,5);
QInsert(L1,9);
QInsert(L1,1);
QInsert(L1,6);
QInsert(L1,2);
Print(L1);
QInsert(L1,12);
QDelete(L1);
QDelete(L1);
QDelete(L1);
QInsert(L1,19);
Print(L1);
}。

相关文档
最新文档