数据结构实验4队列

合集下载

数据结构实验报告(C语言)(强力推荐)

数据结构实验报告(C语言)(强力推荐)

数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。

学习基本的查找和排序技术。

让我们在实际上机中具有编制相当规模的程序的能力。

养成一种良好的程序设计风格。

实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。

本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。

②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。

本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。

㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。

数据结构单元4演习参考答案

数据结构单元4演习参考答案

B.可以变动
对全部高中资料试卷电气设备,在安装过程中以及安装结束后进行高中资料试卷调整试验;通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关,通系电1,力过根保管据护线生高0不产中仅工资2艺料22高试2可中卷以资配解料置决试技吊卷术顶要是层求指配,机置对组不电在规气进范设行高备继中进电资行保料空护试载高卷与中问带资题负料2荷试2,下卷而高总且中体可资配保料置障试时2卷,32调需3各控要类试在管验最路;大习对限题设度到备内位进来。行确在调保管整机路使组敷其高设在中过正资程常料1工试中况卷,下安要与全加过,强度并看工且25作尽52下可22都能护可地1关以缩于正小管常故路工障高作高中;中资对资料于料试继试卷电卷连保破接护坏管进范口行围处整,理核或高对者中定对资值某料,些试审异卷核常弯与高扁校中度对资固图料定纸试盒,卷位编工置写况.复进保杂行护设自层备动防与处腐装理跨置,接高尤地中其线资要弯料避曲试免半卷错径调误标试高方中等案资,,料要编试求5写、卷技重电保术要气护交设设装底备备置。4高调、动管中试电作线资高气,敷料中课并设3试资件且、技卷料中拒管术试试调绝路中验卷试动敷包方技作设含案术,技线以来术槽及避、系免管统不架启必等动要多方高项案中方;资式对料,整试为套卷解启突决动然高过停中程机语中。文高因电中此气资,课料电件试力中卷高管电中壁气资薄设料、备试接进卷口行保不调护严试装等工置问作调题并试,且技合进术理行,利过要用关求管运电线行力敷高保设中护技资装术料置。试做线卷到缆技准敷术确设指灵原导活则。。:对对在于于分调差线试动盒过保处程护,中装当高置不中高同资中电料资压试料回卷试路技卷交术调叉问试时题技,,术应作是采为指用调发金试电属人机隔员一板,变进需压行要器隔在组开事在处前发理掌生;握内同图部一纸故线资障槽料时内、,设需强备要电制进回造行路厂外须家部同出电时具源切高高断中中习资资题料料电试试源卷卷,试切线验除缆报从敷告而设与采完相用毕关高,技中要术资进资料行料试检,卷查并主和且要检了保测解护处现装理场置。设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况,然后根据规范与规程规定,制定设备调试高中资料试卷方案。

实验报告

实验报告

实验报告课题名称:数据结构与算法班级:09网络工程姓名:杨益良学号:2009181105指导老师:梁海丽实验一:线性表的顺序存储一、实验目的1.掌握用C语言调试程序的基本方法。

2.掌握线性表顺序存储的基本运算,如插入、删除等。

二、实验内容线性表在顺序存储结构上的插入元素,删除元素运算三、实验要求1.C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,要求给出具体的算法分析结果,并简要给出算法设计小结和心得。

四、源程序#include<stdio.h>#define MAXSIZE 100int list[MAXSIZE];int n;/*insert in a seqlist*/int sq_insert(int list[], int *p_n, int i, int x){int j;if (i<0 || i>*p_n) return(1);if (*p_n==MAXSIZE) return(2);for (j=*p_n+1; j>i; j--)list[j]=list[j-1];list[i]=x;(*p_n)++;return(0);}/*delete in a seq list*/int sq_delete(int list[], int *p_n, int i){int j;if (i<0 || i>=*p_n) return(1);for (j = i+1; j<=*p_n; j++)list[j-1] = list[j];(*p_n)--;return(0);}void main(){int i,x,temp;printf("please input the number for n\n");printf("n=");scanf("%d",&n);for (i=0; i<=n; i++){printf("list[%d]=",i);scanf("%d",&list[i]);}printf("The list before insertion is\n");for (i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("please input the position where you want to insert a value\nposition=");scanf("%d",&i);printf("please input the value you want to insert.\nx=");scanf("%d",&x);temp=sq_insert(list,&n,i,x);switch(temp){case 0:printf("The insertion is successful!\n");printf("The list is after insertion is\n");for(i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("%d\n",n);break;case 1:case 2:printf("The insertion is not successful!\n");break;}/*deleting*/printf("The list before deleting is\n");for (i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("please input the position where you want to delete a value\nposition=");scanf("%d",&i);temp=sq_delete(list,&n,i);switch(temp){case 0:printf("The deleting is successful!\n");printf("The list is after deleting is\n");for(i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("%d",n);break;case 1:printf("The deleting is not successful!");break;}}五、程序运行情况六、实验结果分析在顺序表中插入一个元素后,插入位置及之后的元素后移表长增长1;在顺序表中删除一个元素后,插入位置及之前的元素左移,表长减1;在该实验通过c语言调试程序了解并掌握了线性表在顺序存储结构上插入元素、删除元素的算法设计及相关程序设计和实现方法。

数据结构实验报告实验总结

数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。

通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。

下面对每一部分实验进行总结。

实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。

在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。

实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。

实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。

通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。

实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。

通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。

通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。

同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。

在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。

通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。

总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。

数据结构实验4:C++实现循环队列

数据结构实验4:C++实现循环队列

数据结构实验4:C++实现循环队列实验44.1 实验⽬的熟练掌握队列的顺序存储结构和链式存储结构。

熟练掌握队列的有关算法设计,并在循环顺序队列和链队列上实现。

根据具体给定的需求,合理设计并实现相关结构和算法。

4.2 实验要求4.2.1 循环顺序队列的实验要求循环顺序队列结构和运算定义,算法的实现以库⽂件⽅式实现,不得在测试主程序中直接实现;实验程序有较好可读性,各运算和变量的命名直观易懂,符合软件⼯程要求;程序有适当的注释。

4.3 实验任务4.3.1 循环顺序队列实验任务编写算法实现下列问题的求解。

<1>初始化⼀个队列。

<2>判断是否队空。

<3>判断是否队满。

设队列最⼤长度:MaxLen=100第⼀组数据:⼊队n个元素,判断队满第⼆组数据:⽤循环⽅式将1到99,99个元素⼊队,判队满<4>⼊队第⼀组数据:4,7,8,12,20,50第⼆组数据:a,b,c,d,f,g<5>出队<6>取队头元素<7>求当前队列中元素个数<8>编写算法实现①初始化空循环队列;②当键盘输⼊奇数时,此奇数⼊队;③当键盘输⼊偶数时,队头出队;④当键盘输⼊0时,算法退出;⑤每当键盘输⼊后,输出当前队列中的所有元素。

4.5 运⾏结果截图及说明图1 测试(1)、(2)、(3)、(5)、(6)、(7)图2 测试(4)图3 测试(4)图4 测试(8)4.6 附源代码1// stdafx.h : include file for standard system include files,2// or project specific include files that are used frequently, but3// are changed infrequently4//56#if !defined(AFX_STDAFX_H__8FA49CDF_FC99_4984_AB37_46921F7ED357__INCLUDED_)7#define AFX_STDAFX_H__8FA49CDF_FC99_4984_AB37_46921F7ED357__INCLUDED_89#if _MSC_VER > 100010#pragma once11#endif// _MSC_VER > 10001213 #include <stdc++.h>1415using namespace std;1617 typedef int elementType;18 typedef char elementType1;19const int maxn = 100;2021// TODO: reference additional headers your program requires here2223//{{AFX_INSERT_LOCATION}}24// Microsoft Visual C++ will insert additional declarations immediately before the previous line.2526#endif// !defined(AFX_STDAFX_H__8FA49CDF_FC99_4984_AB37_46921F7ED357__INCLUDED_)1// _SeqCircleQueue.h: interface for the _SeqCircleQueue class.2//3//////////////////////////////////////////////////////////////////////45#if !defined(AFX__SEQCIRCLEQUEUE_H__FCBC0603_27E1_4352_833C_6BED9B418B96__INCLUDED_) 6#define AFX__SEQCIRCLEQUEUE_H__FCBC0603_27E1_4352_833C_6BED9B418B96__INCLUDED_78#if _MSC_VER > 10009#pragma once10#endif// _MSC_VER > 10001112class _SeqCircleQueue13 {14public:15 _SeqCircleQueue();16virtual ~_SeqCircleQueue();17bool emptySeqCircleQueue();18bool fullSeqCircleQueue();19bool enQueue( elementType value );20bool deQueue( elementType &value );21bool getFront( elementType &value );22int length();23void oddOrEven( elementType value );24 friend ostream &operator<<( ostream &os, _SeqCircleQueue &scq )25 {26if( ( scq._front - 1 ) % maxn == scq._rear )27return os;28int column = 0;29for( int i = scq._front; i % maxn != scq._rear; i = ( i + 1 ) % maxn )30 {31 os << setw(3) << setiosflags(ios::left) << scq.data[i] << "";32 column ++;33if( column % 10 == 0 )34 os << endl;35 }36 os << endl;37 }39 elementType data[maxn];40int _front;41int _rear;4243 };4445#endif// !defined(AFX__SEQCIRCLEQUEUE_H__FCBC0603_27E1_4352_833C_6BED9B418B96__INCLUDED_) 1// _SeqCircleQueue.cpp: implementation of the _SeqCircleQueue class.2//3//////////////////////////////////////////////////////////////////////45 #include "stdafx.h"6 #include "_SeqCircleQueue.h"78//////////////////////////////////////////////////////////////////////9// Construction/Destruction10//////////////////////////////////////////////////////////////////////1112 _SeqCircleQueue::_SeqCircleQueue()13 {14 _front = _rear = 0;15 }1617 _SeqCircleQueue::~_SeqCircleQueue()18 {19 ios::sync_with_stdio(false);20 cout << "The _SeqCircleQueue destruction has been called!" << endl;21 }2223bool _SeqCircleQueue::emptySeqCircleQueue()24 {25return _front == _rear;26 }2728bool _SeqCircleQueue::fullSeqCircleQueue()29 {30return ( _rear + 1 ) % maxn == _front;31 }3233bool _SeqCircleQueue::enQueue( elementType value )34 {35if( fullSeqCircleQueue() )36 {37 cerr << "Seq-Circle-Queue is full!Error in _SeqCircleQueue::enQueue()!" << endl;38return false;39 }40 data[_rear] = value;41 _rear = ( _rear + 1 ) % maxn;42return true;43 }4445bool _SeqCircleQueue::deQueue( elementType &value )46 {47if( emptySeqCircleQueue() )48 {49 cerr << "Seq-Circle-Queue is empty!Error in _SeqCircleQueue::popFront()!" << endl;50return false;51 }52 value = data[_front];53 _front = ( _front + 1 ) % maxn;54return true;55 }5657bool _SeqCircleQueue::getFront( elementType &value )58 {59if( emptySeqCircleQueue() )60 {61 cerr << "Seq-Circle-Queue is empty!Error in _SeqCircleQueue::getFront()!" << endl;62return false;63 }64 value = data[_front];65return true;66 }6768int _SeqCircleQueue::length()69 {70if( emptySeqCircleQueue() )72 cerr << "Seq-Circle-Queue is empty!Error in _SeqCircleQueue::length()!" << endl;73return -1;74 }75return ( _rear - _front + maxn ) % maxn;76 }7778void _SeqCircleQueue::oddOrEven( elementType value )79 {80if( value & 1 )81 {82 enQueue(value);83 cout << value << " will be added to the queue!" << endl;84 cout << (*this);85 }86else if( !( value & 1) && value != 0 )87 {88 elementType x;89 deQueue(x);90 cout << x << " has been deleted from the queue!" << endl;91 cout << (*this);92 }93else//if( value == 0 )94 {95 cout << "The _SeqCircleQueue::oddOrEven() has been stoped!" << endl;96return;97 }98 }1// charSeqCircleQueue.h: interface for the charSeqCircleQueue class.2//3//////////////////////////////////////////////////////////////////////45#if !defined(AFX_CHARSEQCIRCLEQUEUE_H__FBB4F8DD_2EF9_43A6_8E23_FD7E4C56908E__INCLUDED_)6#define AFX_CHARSEQCIRCLEQUEUE_H__FBB4F8DD_2EF9_43A6_8E23_FD7E4C56908E__INCLUDED_78#if _MSC_VER > 10009#pragma once10#endif// _MSC_VER > 10001112class charSeqCircleQueue13 {14public:15 charSeqCircleQueue();16virtual ~charSeqCircleQueue();17bool emptyCharSeqCircleQueue();18bool fullCharSeqCircleQueue();19bool enQueue( elementType1 value );20bool deQueue( elementType1 &value );21bool getFront( elementType1 &value );22int length();23 friend ostream &operator<<( ostream &os, charSeqCircleQueue &cscq )24 {25if( ( cscq._front - 1 ) % maxn == cscq._rear )26return os;27int column = 0;28for( int i = cscq._front; i % maxn != cscq._rear; i = ( i + 1 ) % maxn )29 {30 os << setw(3) << setiosflags(ios::left) << cscq.data[i] << "";31 column ++;32if( column % 10 == 0 )33 os << endl;34 }35 os << endl;36 }37private:38 elementType1 data[maxn];39int _front;40int _rear;4142 };4344#endif// !defined(AFX_CHARSEQCIRCLEQUEUE_H__FBB4F8DD_2EF9_43A6_8E23_FD7E4C56908E__INCLUDED_) 1// charSeqCircleQueue.cpp: implementation of the charSeqCircleQueue class.3//////////////////////////////////////////////////////////////////////45 #include "stdafx.h"6 #include "charSeqCircleQueue.h"78//////////////////////////////////////////////////////////////////////9// Construction/Destruction10//////////////////////////////////////////////////////////////////////1112 charSeqCircleQueue::charSeqCircleQueue()13 {14 _front = _rear = 0;15 }1617 charSeqCircleQueue::~charSeqCircleQueue()18 {19 ios::sync_with_stdio(false);20 cout << "The charSeqCircleQueue destruction has been called!" << endl;21 }2223bool charSeqCircleQueue::emptyCharSeqCircleQueue()24 {25return _front == _rear;26 }2728bool charSeqCircleQueue::fullCharSeqCircleQueue()29 {30return ( _rear + 1 ) % maxn == _front;31 }3233bool charSeqCircleQueue::enQueue( elementType1 value )34 {35if( fullCharSeqCircleQueue() )36 {37 cerr << "Seq-Circle-Queue is full!Error in charSeqCircleQueue::::enQueue()!" << endl; 38return false;39 }40 data[_rear] = value;41 _rear = ( _rear + 1 ) % maxn;42return true;43 }4445bool charSeqCircleQueue::deQueue( elementType1 &value )46 {47if( emptyCharSeqCircleQueue() )48 {49 cerr << "Seq-Circle-Queue is empty!Error in charSeqCircleQueue::popFront()!" << endl; 50return false;51 }52 value = data[_front];53 _front = ( _front + 1 ) % maxn;54return true;55 }5657bool charSeqCircleQueue::getFront( elementType1 &value )58 {59if( emptyCharSeqCircleQueue() )60 {61 cerr << "Seq-Circle-Queue is empty!Error in charSeqCircleQueue::::getFront()!" << endl; 62return false;63 }64 value = data[_front];65return true;66 }6768int charSeqCircleQueue::length()69 {70if( emptyCharSeqCircleQueue() )71 {72 cerr << "Seq-Circle-Queue is empty!Error in charSeqCircleQueue::::length()!" << endl; 73return -1;74 }75return ( _rear - _front + maxn ) % maxn;76 }4.7 调试过程中出现的bug总结注意细节!。

数据结构实验报告-队列的操作

数据结构实验报告-队列的操作
printf("元素入队列");
for(i=0 ; i<10; i++)
{
printf(" %d ",j);
EnQueue(S,j); //元素入队列
j++;
}
printf("\n元素出队列");
for(i=0 ; i<10; i++)
{
DeQueue(S,j); //元素出队列
printf(" %d ",j);
}
}
运行结果截图:
1.
四、分析与讨论
对上机实践结果进行分析,上机的心得体会。
五、教师评语
签名:
日期:
成绩
附源程序清单:
1.#include<iostream>
#include<queue>
using namespace std;
void main()
{
queue<char> cque;
char c;
typedef struct {
QElemType *base; // 动态分配存储空间
int front; // 头指针,若队列不空,指向队列头元素
int rear; // 尾指针,若队列不空, //指向队列尾元素 的下一个位置
}SqQueue;
Status InitQueue (SqQueue &Q) { // 构造一个空队列Q
if ((Q.rear+1) % MAXQSIZE == Q.front)
return ERROR; //队列满
Q.base[Q.rear] = e;

数据结构队列实验报告

数据结构队列实验报告

数据结构队列实验报告
《数据结构队列实验报告》
实验目的:通过实验观察和分析队列数据结构的基本特性和操作,加深对队列
的理解和掌握。

实验内容:
1. 实现队列的基本操作:入队、出队、判空、判满等;
2. 使用队列解决实际问题:如模拟排队、实现广度优先搜索等;
3. 对队列的性能进行分析和比较。

实验步骤:
1. 设计并实现队列的基本操作函数;
2. 编写测试程序,对队列进行入队、出队等操作;
3. 使用队列解决实际问题,观察队列的应用效果;
4. 对队列的性能进行分析,比较不同实现方式的性能差异。

实验结果:
1. 队列的基本操作函数能够正确地实现入队、出队等操作;
2. 使用队列解决实际问题时,队列能够有效地管理数据,提高问题的解决效率;
3. 对队列的性能进行分析后发现,在数据量较大时,不同实现方式的性能差异
较大。

实验结论:
通过本次实验,深入理解了队列数据结构的基本特性和操作,并掌握了队列的
应用方法。

同时,通过对队列的性能进行分析和比较,也加深了对数据结构的
性能优化的理解。

队列作为一种重要的数据结构,在实际应用中具有广泛的用
途,对其理解和掌握对于提高程序的效率和性能具有重要意义。

队列的建立及操作

队列的建立及操作

队列的建⽴及操作数据结构与算法 --> 实验报告 4实验项⽬名称:队列的建⽴及操作⼀、实验⽬的1.掌握队列存储结构的表⽰和实现⽅法。

2.掌握队列的⼊队和出队等基本操作的算法实现。

⼆、实验题建⽴顺序循环队列,并在顺序循环队列上实现⼊队、出队基本操作。

三、实验过程及结果①基本思路:采⽤⼀种循环的结构去实现队列的顺序存储,队满和队空时标志都是 Q->front=Q->rear;为了区别两种情况,我的思路是:修改队满条件,浪费⼀个元素空间,当只有⼀个空闲单元时队满。

程序代码:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define MAXSIZE 10typedef int QElemType;typedef struct{QElemType \*base;int front;int rear;}SqQueue;Status InitQueue(SqQueue \*Q){Q->base = (QElemType *)malloc(MAXSIZE * sizeof(QElemType));if (Q->base==NULL) exit(OVERFLOW);Q->front = Q->rear = 0;return OK;}Status EnQueue(SqQueue \*Q,QElemType e){if ((Q->rear + 1) % MAXSIZE == Q->front)return ERROR;Q->base[Q->rear] = e;Q->rear = (Q->rear + 1) % MAXSIZE;return OK;}Status DeQueue(SqQueue *Q, QElemType *e){if (Q->front == Q->rear)return ERROR;*e = Q->base[Q->front];Q->front = (Q->front + 1) % MAXSIZE;return OK;}int main() {SqQueue Q;QElemType e;InitQueue(&Q);for (int i = 2; i < 7; i++){EnQueue(&Q, i);printf("⼊队元素为%d\n", i);}for (int j=2; j <7; j++) {DeQueue(&Q, &e);printf("出队元素为%d\n", e);}return 0;}②实验结果:四、实验总结队列的顺序存储采⽤循环队列,为了区分队空和队满,当只有⼀个空闲单元时队满。

队列实验报告

队列实验报告

队列实验报告队列实验报告引言:队列是一种常见的数据结构,它按照先进先出(FIFO)的原则管理数据。

在计算机科学中,队列被广泛应用于各种算法和数据处理任务中。

本实验旨在通过实际操作和观察,深入了解队列的特性和应用。

实验目的:1. 理解队列的基本概念和特性;2. 学会使用队列进行数据处理;3. 掌握队列在实际问题中的应用。

实验步骤:1. 队列的创建和初始化:首先,我们需要创建一个队列并进行初始化。

队列可以使用数组或链表来实现。

在本实验中,我们选择使用链表实现队列。

通过定义一个队列类,我们可以创建一个空队列,并为其设置头节点和尾节点。

2. 入队操作:入队操作是将元素添加到队列的末尾。

我们可以通过调用队列类的入队方法,在尾节点后插入新的节点。

在插入操作之前,我们需要判断队列是否为空。

如果队列为空,新节点将成为头节点和尾节点;如果队列不为空,新节点将链接到当前尾节点的后面,并成为新的尾节点。

3. 出队操作:出队操作是将队列中的第一个元素移除,并返回该元素的值。

我们可以通过调用队列类的出队方法,将头节点的下一个节点作为新的头节点,并返回旧的头节点的值。

在出队操作之前,我们同样需要判断队列是否为空。

如果队列为空,则无法进行出队操作。

4. 遍历队列:为了观察队列中的元素,我们可以使用遍历操作。

通过遍历队列,我们可以依次访问每个节点,并输出节点的值。

在遍历过程中,我们需要从头节点开始,依次访问每个节点的下一个节点,直到尾节点为止。

实验结果:通过上述实验步骤,我们可以得到以下结果:1. 队列的创建和初始化成功;2. 入队操作能够将元素添加到队列的末尾;3. 出队操作能够将队列中的第一个元素移除,并返回该元素的值;4. 遍历操作能够依次输出队列中的每个元素。

实验应用:队列在实际问题中有着广泛的应用。

以下是一些典型的应用场景:1. 消息队列:在分布式系统中,消息队列被用于异步通信和解耦。

生产者可以将消息发送到队列,而消费者可以从队列中获取消息并进行处理。

第4章 队列

第4章 队列

4-2
队列的存储实现及运算实现
4-2-1 顺序队列
1.顺序队列
顺序队列是用内存中一组连续的存储单元顺序存放队 列中各元素。所以可以用一维数组Q[MAXLEN]作为队列 的顺序存储空间,其中MAXLEN为队列的容量,队列元素 从Q[0]单元开始存放,直到Q[MAXLEN–1]单元。因为队 头和队尾都是活动的,因此,除了队列的数据以外,一般 还设有队首(front)和队尾(rear)两个指针。
出队
入队
a1 a2 a3 a4 a5 … … an
图4-1 队列示意图
4. 队列的实例
(1)如车站排队买票或自动取款机排队取款。 (2)在计算机处理文件打印时,为了解决高速的CPU与低 速的打印机之间的矛盾,对于多个请求打印文件,操作系 统把它们当作可以被延迟的任务,提出打印任务的先后顺 序,就是它们实际打印的先后顺序。即按照“先进先出” 的原则形成打印队列。
2.循环队列
为了解决上述队列的“假溢出”现象,要做移动操作, 当移动数据较多时将会影响队列的操作速度。一个更有效 的方法是将队列的数据区Q[0 ..MAXLEN-1]看成是首尾相连 的 环 , 即 将 表 示 队 首 的 元 素 Q[0] 与 表 示 队 尾 的 元 素 Q[MAXLEN–1]连接起来,形成一个环形表,这就成了循环队 列,如图4-3所示。
第 4 章 目录
队列的定义和基本运算 4-2 队列的存储及运算的实现 4-3 队列的应用举例 小 结 实验4 队列子系统 习题4
4-1
4-1
队列的定义和基本运算
4-1-1 队列(Queue)的定义
1.队列的定义 设有n个元素的队列Q=(a1,a2,a3,…,an),则称a1 为队首元素,an 为队尾元素。队列中的元素按,a1 ,a2 , a3,…,an–1 ,an的次序进队,按a 1,a2,a3,…,an–1 ,an 次序出队,即队列的操作是按照“先进先出” 的原则进行的。 2. 队列的特性 (1)队列的主要特性是“先进先出”。 (2)队列是限制在两端进行插入和删除操作的线性表。 能够插入元素的一端称为 队尾(Rear),允许删除元素 的一端称为 队首(Front)。

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈,出栈操作;2、掌握队列的结构特性及其⼊队、出队的操作,掌握循环队列的特点及其操作。

⼆、实验预习说明以下概念1、顺序栈:2、链栈:3、循环队列:4、链队三、实验内容和要求1、阅读下⾯程序,将函数Push和函数Pop补充完整。

要求输⼊元素序列1 2 3 4 5 e,运⾏结果如下所⽰。

#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析:输⼊元素序列1 2 3 4 5,为什么输出序列为5 4 3 2 1?体现了栈的什么特性?2、在第1题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。

队列操作实验报告

队列操作实验报告

队列操作实验报告队列操作实验报告一、引言队列是一种常见的数据结构,它按照先进先出(First In First Out,FIFO)的原则进行操作。

队列的应用非常广泛,例如在计算机科学中,队列被用于实现进程调度、缓存管理等。

为了更好地理解队列的操作以及其在实际应用中的作用,我们进行了一系列队列操作的实验。

二、实验目的本次实验的目的是通过编程实现队列的基本操作,包括入队、出队、判空、获取队首元素等。

通过实际操作,加深对队列的理解,并验证队列的功能是否正常。

三、实验过程1. 队列的定义在开始实验之前,我们首先定义了一个队列的数据结构。

队列由一个数组和两个指针front和rear组成。

其中,front指向队首元素,rear指向队尾元素。

2. 入队操作入队操作是将一个元素插入到队列的尾部。

我们通过编程实现了入队操作,并进行了测试。

测试结果表明,入队操作能够成功将元素插入到队列的尾部,并更新rear指针的位置。

3. 出队操作出队操作是将队列的首部元素删除,并返回该元素的值。

我们编写了出队操作的代码,并进行了测试。

测试结果表明,出队操作能够成功删除队列的首部元素,并返回正确的值。

4. 判空操作判空操作是判断队列是否为空。

我们编写了判空操作的代码,并进行了测试。

测试结果表明,判空操作能够正确地判断队列是否为空。

5. 获取队首元素获取队首元素操作是返回队列的首部元素的值,但不删除该元素。

我们编写了获取队首元素的代码,并进行了测试。

测试结果表明,获取队首元素操作能够正确地返回队列的首部元素的值。

四、实验结果与分析通过对队列的各种操作进行实验,我们验证了队列的功能是否正常。

实验结果表明,队列的入队、出队、判空和获取队首元素操作都能够正常运行,并返回正确的结果。

这说明我们所实现的队列数据结构是正确的,并且满足了队列的基本操作要求。

在实际应用中,队列常被用于解决一些问题。

例如,在操作系统中,队列被用于实现进程调度。

当多个进程同时请求资源时,操作系统会将这些进程按照先来先服务的原则排队,然后依次分配资源。

数据结构实验报告队列的表示与实现

数据结构实验报告队列的表示与实现
//从队头到队尾依次对队列Q中的每个元素调用函数visit()。
一旦visit失败, 则操作失败。
链队列:
//单链队列-—队列的链式存储结构
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
if(! Q.front )exit(OVERFLOW); //存储分配失败
Q.front —〉next =NULL;
return OK;}
Status DestoryQueue(LinkQueue &Q){//销毁队列Q, Q不再存在
while(Q.front){
Q。rear=Q.front —〉next;
DestoryQueue(&Q)//初始条件:队列Q已存在
//操作结果: 队列Q被销毁, 不再存在
ClearQueue(&Q)//初始条件:队列Q已存在
//操作结果: 将Q清为空队列
QueueEmpty(Q)//初始条件: 队列Q已存在
//操作结果:若队列Q为空队列, 则返回TRUE, 否则FALSE
QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue;
//—---—单链队列的基本操作的算法描述—-————
status INitQueue(LinkQueue &Q){//构造一个空队列Q
Q.front=Q。rear=(QueuePtr)malloc(sizeof(QNode));
数据结构实验报告
姓名
学号

实验地点
数学楼

队列应用实验报告

队列应用实验报告

队列应用实验报告队列应用实验报告引言:队列是一种常见的数据结构,它按照先进先出(FIFO)的原则进行操作。

在计算机科学中,队列被广泛应用于各种领域,如操作系统、网络通信、图形处理等。

本实验旨在通过实际应用,探索队列在实际问题中的应用。

一、队列在操作系统中的应用在操作系统中,队列被用于进程调度。

操作系统通过维护一个就绪队列,按照进程的优先级或到达时间将进程排队。

当一个进程执行完毕或者发生中断时,操作系统从队列中选择下一个要执行的进程。

这种方式确保了每个进程都能按照一定的规则获得CPU的使用权,提高了系统的效率。

二、队列在网络通信中的应用在网络通信中,队列被用于处理数据包。

当数据包到达网络节点时,它们会被放入队列中等待处理。

队列中的数据包按照先后顺序进行处理,保证了数据的有序性。

同时,队列还可以用于解决网络拥塞的问题。

当网络负载过高时,数据包会被放入队列中等待发送,以避免数据的丢失。

三、队列在图形处理中的应用在图形处理中,队列被用于实现图像渲染。

当一个图像需要被渲染时,图像的每个像素点都需要经过一系列的计算和处理。

这些计算和处理的顺序可以通过队列来管理。

每个像素点都被放入队列中,然后按照队列的顺序进行处理。

这种方式可以确保图像的每个像素点都按照正确的顺序进行渲染,保证了图像的质量。

四、队列在实际生活中的应用队列不仅在计算机科学中有广泛的应用,也在我们的日常生活中发挥着重要的作用。

例如,在超市排队结账时,我们都会排队等待。

超市通过维护一个顾客队列,按照先后顺序为每个顾客提供服务。

这种方式保证了每个顾客都能按照一定的规则被服务,提高了服务效率。

结论:队列作为一种常见的数据结构,在各个领域都有重要的应用。

通过本实验,我们对队列的应用有了更深入的了解。

队列的先进先出原则使得它在处理需要按照顺序进行的任务时非常有效。

无论是在操作系统、网络通信还是图形处理中,队列都能发挥重要的作用。

同时,队列在我们的日常生活中也有广泛的应用,帮助我们提高效率和组织秩序。

《数据结构》实验书

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)(特别提示:程序设计包含两个方面的错误。

其一是错误,其二是能错误。

为了提高学生的编程和能力,本指导书给出的程序代码并的两种错误。

并且也不保证程序的完整性,有一些语句已经故意删除,就是要求学生自己编制完成,这样才能达到我们的要求。

希望大家以自己所学高级语言的基本功和点为基础,不要过于依赖给出的参考代码,这样才能有所进步。

如果学生能够根据要求完全自己编制,那就不好了。

)实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结分主要功能,也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通据的函数。

【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。

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

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

数据结构栈和队列实验报告数据结构栈和队列实验报告引言:数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便于程序的运行和管理。

栈和队列是数据结构中最基本的两种形式之一,它们在实际应用中有着广泛的应用。

本实验旨在通过实际操作和观察,深入理解栈和队列的特性和应用。

一、实验目的:1. 了解栈和队列的基本概念和特性;2. 掌握栈和队列的基本操作;3. 理解栈和队列在实际应用中的作用。

二、实验过程:本次实验我们使用Python语言来实现栈和队列的操作。

首先,我们定义了栈和队列的类,并编写了相应的操作方法。

1. 栈的实现:栈是一种后进先出(LIFO)的数据结构,类似于我们日常生活中的弹簧簿记本。

我们首先定义了一个栈类,其中包括了栈的初始化、入栈、出栈、获取栈顶元素等方法。

通过这些方法,我们可以对栈进行各种操作。

2. 队列的实现:队列是一种先进先出(FIFO)的数据结构,类似于我们日常生活中的排队。

我们同样定义了一个队列类,其中包括了队列的初始化、入队、出队、获取队首元素等方法。

通过这些方法,我们可以对队列进行各种操作。

三、实验结果:我们通过实验,成功实现了栈和队列的基本操作。

在测试过程中,我们发现栈和队列在实际应用中有着广泛的用途。

1. 栈的应用:栈在计算机系统中有着重要的作用,例如在函数调用中,每次函数调用时都会将返回地址和局部变量等信息存储在栈中,以便于函数执行完毕后能够正确返回。

此外,栈还可以用于表达式求值、括号匹配等场景。

2. 队列的应用:队列在操作系统中常用于进程调度,通过维护一个就绪队列,操作系统可以按照一定的策略选择下一个要执行的进程。

此外,队列还可以用于消息传递、缓冲区管理等场景。

四、实验总结:通过本次实验,我们深入了解了栈和队列的特性和应用。

栈和队列作为数据结构中最基本的两种形式,它们在计算机科学中有着广泛的应用。

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

数据结构实验——队列(附程序)

数据结构实验——队列(附程序)

数据结构实验——队列(附程序) 目录1.引言2.队列的定义与性质2.1 队列的概念2.2 队列的性质2.2.1 先进先出性质2.2.2 顺序存储和链式存储3.队列的基本操作3.1 初始化队列3.2 入队操作3.3 出队操作3.4 判空操作3.5 获取队头元素4.队列的应用4.1 模拟排队系统4.2 广度优先搜索(bfS)4.3 线程池任务调度5.队列的实现5.1 顺序队列的实现5.2 链式队列的实现6.程序示例6.1 顺序队列的实现代码6.2 链式队列的实现代码7.实验结果与分析8.总结与展望1.引言本文档旨在介绍队列数据结构及其实验分析。

队列作为一种基本数据结构在计算机科学中应用广泛,本文将从队列的定义与性质开始,介绍队列的基本操作和应用,并提供队列的实现示例。

2.队列的定义与性质2.1 队列的概念队列是一种具有先进先出(first in first Out,fifO)特性的线性数据结构。

它可以通过尾部插入元素,头部删除元素。

2.2 队列的性质2.2.1 先进先出性质队列的先进先出性质意味着最早插入的元素将首先被访问或删除,而最新插入的元素将最后被访问或删除。

2.2.2 顺序存储和链式存储队列可以通过顺序存储和链式存储来实现。

顺序存储使用数组实现,具有随机访问的特性,但容量固定。

链式存储使用链表实现,没有容量限制,但访问速度较慢。

3.队列的基本操作3.1 初始化队列队列的初始化操作用于创建一个空的队列供后续操作使用。

3.2 入队操作入队操作将一个元素插入到队列的尾部,使其成为新的队尾。

3.3 出队操作出队操作将队头元素删除,并返回该元素的值。

3.4 判空操作判空操作用于判断队列是否为空。

3.5 获取队头元素获取队头元素操作返回队列头部的元素值,但不删除。

4.队列的应用4.1 模拟排队系统队列可以用来模拟现实中的排队系统,如银行柜台、售票窗口等。

通过模拟排队系统,我们可以评估业务处理的效率、平均等待时间等指标。

数据结构实验任务书(8个)

数据结构实验任务书(8个)

目录实验1 线性表顺序存储的应用 (2)实验2 线性表链式存储的应用 (5)实验3 栈及其应用 (6)实验4 队列及其应用 (7)实验5 树及其应用 (8)实验6 图的遍历和连通性应用 (9)实验7 图的最短路径应用 (11)实验8 查找和排序应用 (12)实验1 线性表顺序存储的应用实验目的1.熟悉C语言的上机环境,掌握C语言的基本结构。

2.会定义线性表的顺序存储结构。

3.熟悉对顺序表的一些基本操作和具体的函数定义。

4.掌握在线性表的顺序存储结构上的一些其它操作。

实验要求1.独立完成;2.程序调试正确,有执行结果。

实验内容1、基础题:编写应用程序(填空),实现可以在顺序表中插入任意给定数据类型(定义为抽象数据类型)数据的功能。

要求在主函数中定义顺序表并对该顺序表插入若干个整数类型的数据(正整数),对它们求和并输出。

请使用动态内存分配的方式申请数组空间,并把主函数设计为一个文件SeqList.cpp,其余函数设计为另一个文件SeqList.h。

请填空完成以下给出的源代码并调试通过。

(1)文件SeqList.h:typedef struct List{ElemType *elem;int length;int listsize;}SeqList;void InitList(SeqList &L){ //初始化线性表…………}void ClearList(SeqList &L){ //清除线性表………………}int LengthList(SeqList L){ //求线性表长度………..}bool InsertList(SeqList &L, ElemType item, int pos){ //按给定条件pos向线性表插入一个元素…….}ElemType GetList(SeqList L, int pos){ //在线性表L中求序号为pos的元素,该元素作为函数值返回…………..}(2)文件SeqList.cpp:#include <stdio.h>#include <stdlib.h>typedef ElemType;#define MAXSize 10#include "SeqList.h"void main(void){SeqList myList;int i=1, x, sum=0, n;InitList ( );scanf(“%d”, &x);while ( x!= -1 ){if ( InsertList (myList, , i )==0) {printf("错误!\n");return ;}i++;scanf(“%d”, &x);}n = LengthList (myList);for (i=1; i<=n; i++){x=GetList(myList, i);sum = + x;}printf("%d\n ", sum);ClearList(myList);}2、提高部分:编写函数bool DeleteElem(SeqList &L, int min, int max)实现从顺序表中删除其值在给定值min和max之间(min < max)的所有元素,要求把该函数添加到文件SeqList.h中,并在主函数文件SeqList.cpp中添加相应语句进行测试。

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

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

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

通过实际编程实现堆栈和队列的相关操作,加深对其特性的认识,提高编程能力和解决问题的能力。

二、实验环境本次实验使用的编程语言为 Python,开发工具为 PyCharm。

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

可以将堆栈想象成一个只能从一端进行操作的容器,新元素总是被添加到这一端(称为栈顶),而取出元素也只能从栈顶进行。

堆栈的基本操作包括:1、`push`:将元素压入堆栈。

2、`pop`:弹出堆栈顶部的元素。

3、`peek`:查看堆栈顶部的元素,但不弹出。

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

可以将队列想象成一个排队的队伍,新元素在队尾加入,而取出元素从队首进行。

队列的基本操作包括:1、`enqueue`:将元素加入队列的尾部。

2、`dequeue`:取出并删除队列头部的元素。

3、`front`:查看队列头部的元素,但不取出。

四、实验内容(一)堆栈的实现```pythonclass Stack:def __init__(self):selfitems =def push(self, item):selfitemsappend(item)def pop(self):if not selfis_empty():return selfitemspop()else:return "Stack is empty" def peek(self):if not selfis_empty():return selfitems-1else:return "Stack is empty" def is_empty(self):return len(selfitems) == 0 def size(self):return len(selfitems)```(二)队列的实现```pythonclass Queue:def __init__(self):selfitems =def enqueue(self, item):selfitemsappend(item)def dequeue(self):if not selfis_empty():return selfitemspop(0) else:return "Queue is empty" def front(self):if not selfis_empty():return selfitems0else:return "Queue is empty" def is_empty(self):return len(selfitems) == 0 def size(self):return len(selfitems)```(三)应用实例1、利用堆栈实现括号匹配的验证```pythondef is_balanced_parentheses(exp):stack = Stack()for char in exp:if char in '({':stackpush(char)elif char in ')}':if stackis_empty():return Falsetop = stackpop()if (char ==')' and top!='(') or (char =='}' and top!='{') or (char =='' and top!=''):return Falsereturn stackis_empty()```2、利用队列实现打印杨辉三角的前 n 行```pythondef print_yanghui_triangle(n):queue = Queue()queueenqueue(1)print(1)for i in range(1, n):prev_row =for _ in range(i + 1):num = queuedequeue()prev_rowappend(num)print(num, end="")if _< i:new_num = prev_row_ +(prev_row_ 1 if _> 0 else 0) queueenqueue(new_num)print()```五、实验结果与分析(一)堆栈实验结果对于括号匹配的验证,输入`"((()))"`,输出为`True`,表示括号匹配正确;输入`"((())"`,输出为`False`,表示括号匹配错误。

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

实验4 病人看病模拟程序
【问题描述】
编写一个程序,反映病人到医院看病,排队看医生的情况。

在病人排队的过程中,主要重复两件事:
(1)病人到达诊室,将病历本交给护士,排到等待队列中候诊。

(2)护士从等待队列中取出下一位病人的病历,该病人进入诊室就诊。

要求模拟病人等待就诊这一过程。

程序采用菜单方式,其选项及功能说明如下:
(1)排队――输入排队病人的病历号,加入病人排队队列中。

(2)就诊――病人排队队列中最前面的病人就诊,并将其从队列中删除;
(3)查看排队――从对首到队尾列出所有的排队病人的病历号;(4)不再排队,余下一次就诊――从对首到队尾列出所有的排队病人的病历号,并退出运行;
(5)下班――退出运行;
#include<stdio.h>
#include<malloc.h>
typedef struct qnode
{ int data;
struct qnode *next;
}QNode; //链队结点类型
typedef struct
{
QNode *front,*rear;
}QuType; //链队类型
void seedoctor() //模拟病人看病的过程
{
int sel,flag=1,find,no;
QuType *qu;
QNode *p;
qu=(QuType *)malloc(sizeof(QuType)); //创建空队
qu->front=qu->rear=NULL;
while(flag==1)
{
printf("1:排队 2:就诊 3:查看排队 4:不再排队,余下依次就诊 5:下班请选择:");
scanf("%d",&sel);
switch(sel)
{
case 1: printf(">>输入病历号:");
do
{ scanf("%d",&no);
find=0;
p=qu->front;
while(p!=NULL && !find)
{if(p->data==no)
find=1;
else
p=p->next;
}
if(find)
printf(">>输入的病历号重复,重新输入:");
}while(find==1);
p=(QNode *)malloc(sizeof(QNode)); //创建结点
p->data=no; p->next=NULL;
if(qu->rear==NULL) //第一个病人排队
{
qu->front=qu->rear=p;
}
else
{qu->rear->next=p;
qu->rear=p; //将*p结点入队
}
break;
case 2: if(qu->front==NULL) //队空
printf(">>没有排队的病人!\n");
else
{ p=qu->front;
printf(">>病人%d就诊\n",p->data);
if(qu->rear==p) //只有一个病人排队的情况
{
qu->front=qu->rear=NULL;
}
else
qu->front=p->next;
free(p);
}
break;
case 3:if(qu->front==NULL) // 队空
printf(">>没有排队的病人!\n");
else //队不空
{ p=qu->front;
printf(">>排队病人:");
while(p!=NULL)
{ printf("%d",p->data);
p=p->next;
}
printf("\n");
}
break;
case 4:if(qu->front==NULL) // 队空
printf(">>没有排队的病人!\n");
else //队不空
{ p=qu->front;
printf(">>排队病人:");
while(p!=NULL)
{ printf("%d",p->data);
p=p->next;
}
printf("\n");
}
flag=0; //退出
break;
case 5: if(qu->front!=NULL) //队不空
printf(">>请排队的病人明天就医!\n");
flag=0;
break;
}
}
}
void main() { seedoctor(); }。

相关文档
最新文档