实验二_栈、队列地实现与应用
实验二 栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用一、实验目的1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。
2、会用栈和队列解决简单的实际问题。
二、实验内容(可任选或全做)题目一、试写一个算法,判断依次读入的一个以@为结束符的字符序列,是否为回文。
所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。
相关常量及结构定义:# define STACK_INIT_SIZE 100# define STACKINCREMENT 10# define OK 1# define ERROR 0typedef int SElemType;//栈类型定义typedef struct SqStack{ SElemType *base;SElemType *top;int stacksize;}SqStack;设计相关函数声明:判断函数:int IsReverse()栈:int InitStack(SqStack &S )int Push(SqStack &S, SElemType e )int Pop(SqStack &S,SElemType &e)int StackEmpty(s)题目二、编程模拟队列的管理,主要包括:出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
[实现提示]:参考教材循环队列的有关算法,其中后两个算法参考顺序表的实现。
题目三、RailsDescriptionThere is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited thattime. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track.The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station.InputThe input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0.The last block consists of just one line containing 0.OutputThe output contains the lines corresponding to the lines with permutations in the input.A line of the output contains Yes if it is possible to marshal the coaches in the order required on the corresponding line of the input. Otherwise it contains No. In addition,there is one empty line after the lines corresponding to one block of the input. There is no line in the output corresponding to the last ``null'' block of the input. Sample Input51 2 3 4 55 4 1 2 366 5 4 3 2 1Sample OutputYesNoYes题目四、Sliding WindowDescriptionAn array of size n≤ 106 is given to you. There is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:The array is [1 3 -1 -3 5 3 6 7], and k is 3.Window position Minimum value Maximum value[1 3 -1] -3 5 3 6 7 -131 [3 -1 -3] 5 3 6 7 -331 3 [-1 -3 5] 3 6 7 -351 3 -1 [-3 5 3] 6 7 -351 3 -1 -3 [5 3 6] 7 361 3 -1 -3 5 [3 6 7]37Your task is to determine the maximum and minimum values in the sliding window at each position.InputThe input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.OutputThere are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.Sample Input8 31 3 -1 -3 5 3 6 7Sample Output-1 -3 -3 -3 3 33 3 5 5 6 7题目五(选作考查串知识)DNA Evolution【Description】Evolution is a seemingly random process which works in a way which resembles certain approaches we use to get approximate solutions to hard combinatorial problems. You are now to do something completely different.Given a DNA string S from the alphabet {A,C,G,T}, find the minimal number of copy operations needed to create another string T. You may reverse the strings you copy, and copy both from S and the pieces of your partial T. You may put these pieces together at any time. You may only copy contiguous parts of your partial T, and all copied strings must be used in your final T.Example: From S= “ACTG” create T= “GTACTAATAAT”1.Get GT......... by copying and reversing "TG" from S.2.Get GT AC... by copying "AC" from S.3.Get GTAC TA….. by copying "TA" from the partial T.4.Get GTACTA AT by copying and reversing "TA" from the partial T.5.Get GTACTAAT AAT by copying "AAT" from the partial T.【Input】The first line of input gives a single integer, 1 ≤k≤10, the number of test cases. Then follow, for each test case, a line with the string S , length of S is less then 19, and a line with the string T , length of T is less then 19.【Output】Output for each test case the number of copy operations needed to create T from S, or "impossible" if it cannot be done.【Sample Input】4ACGTTGCAACACGTTCGATCGAAAAAAAAAAAAAAAAAAAA【Sample output】1impossible46题目六(选作考查数组知识)Magic Squares描述Following the success of the magic cube, Mr. Rubik invented its planar version, called magic squares. This is a sheet composed of 8 equal-sized squares:1 2 3 48 7 6 5In this task we consider the version where each square has a different color. Colors are denoted by the first 8 positive integers. A sheet configuration is given by the sequence of colors obtained by reading the colors of the squares starting at the upper left corner and going in clockwise direction. For instance, the configuration of Figure 3 is given by the sequence (1,2,3,4,5,6,7,8). This configuration is the initial configuration.Three basic transformations, identified by the letters `A', `B' and `C', can be applied to a sheet:∙'A': exchange the top and bottom row,∙'B': single right circular shifting of the rectangle,∙'C': single clockwise rotation of the middle four squares.Below is a demonstration of applying the transformations to the initial squares given above:A:8 7 6 51 2 3 4B:4 1 2 35 8 7 6C:1 72 48 6 3 5All possible configurations are available using the three basic transformations.You are to write a program that computes a minimal sequence of basic transformations that transforms the initial configuration above to a specific target configuration.输入A single line with eight space-separated integers (a permutation of (1..8)) that are the target configuration.输出样例输入2 6 8 4 5 73 1样例输出7BCABCCB三、实验步骤㈠、数据结构与核心算法的设计描述㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结四、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)//int IsReverse(){ ….while( (e=getchar())!='@'){e 依次入栈、入队 //push(S,e);EnQueue(Q,e);……..}While(!StackEmpty(S)) { pop(S,a);DeQueue(Q,b);If(a!=b) return 0;}return 1;}。
栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用一_一、实验目的1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。
一_二、实验内容题目一、试写一个算法,判断依次读入的一个以为结束符的字符序列,是否为回文。
所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。
相关常量及结构定义:#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef struct SqStack{ SElemType *base;SElemType *top;int stacksize;}SqStack;设计相关函数声明:判断函数:int IsReverse()栈:int InitStack(SqStack &S )int Push(SqStack &S, SElemType e )int Pop(SqStack &S,SElemType &e)int StackEmpty(s)一_三、数据结构与核心算法的设计描述1、初始化栈/* 函数功能:对栈进行初始化。
参数:栈(SqStack S)。
成功初始化返回0,否则返回-1 */int InitStack(SqStack &S){S.base=(SElemType *)malloc(10*sizeof(SElemType));if(!S.base) //判断有无申请到空间return -1; //没有申请到内存,参数失败返回-1S.top=S.base;S.stacksize=STACK_INIT_SIZE;S.base=new SElemType;return 0;}2、判断栈是否是空/*函数功能:判断栈是否为空。
参数; 栈(SqStack S)。
栈为空时返回-1,不为空返回0*/int StackEmpty(SqStack S){if(S.top==S.base) return -1;else return 0;}3、入栈/*函数功能:向栈中插入元素。
数据结构实验二-栈和队列的基本操作与应用
实验报告课程名称_______数据结构实验__________________ 实验项目___ 栈和队列的基本操作与应用____ 实验仪器_____________________________________系别 ___ 计算机学院_______________ 专业 __________________班级/学号______ _________学生姓名_____________________ __实验日期__________________成绩_______________________指导教师____ __________________一、实验内容:本次实验主要内容是表达式求值,主要通过栈和队列来编写程序,需要实现整数运算其中需要实现的功能有加减乘除以及括号的运用,其中包含优先级的判断。
二、设计思想1.优先级中加减、乘除、小括号、以及其他可以分组讨论优先级2.优先级关系用“>”“<”“=”来表示三种关系3.为实现运算符优先使用两个栈:OPTR 运算符栈与OPND操作符栈4.运用入栈出栈优先级比较等方式完成运算三、主要算法框架1.建立两个栈InitStack(&OPTR);InitStack(&OPND);2.Push“#”到 OPTR3.判断优先级做入栈出栈操作If“<” Push(&OPTR, c);If“=” Pop(&OPTR, &x)If“>” Pop(&OPTR, &theta);Pop(&OPND, &b);Pop(&OPND, &a);Push(&OPND, Operate(a, theta, b));四、调试报告遇到的问题与解决1.C语言不支持取地址符,用*S代替&S来编写代码2.一开始没有计算多位数的功能只能计算一位数,在几个中间不含运算符的数字中间做p = p*10+c运算。
实验二 栈和队列的基本操作及其应用
实验二栈和队列的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应用。
2、掌握栈和队列的特点,即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。
二、实验内容本次实验提供2个题目,每个题目都标有难度系数,*越多难度越大,学生可以根据自己的情况任选一个!题目一:回文判断(*)[问题描述]对于一个从键盘输入的字符串,判断其是否为回文。
回文即正反序相同。
如“abba”是回文,而“abab”不是回文。
[基本要求](1)数据从键盘读入;(2)输出要判断的字符串;(3)利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“ok”,否则输出“fail”。
程序源代码如下:/**********************************用栈和队列进行回文判断输入字符以@结束***********************************/#include <stdio.h>/*定义一个栈*/typedef struct Stack{int size;char * Base;char * Top;}Stack;/*创建一个栈*/void CreateStack(Stack * S,int size) {S -> size = size;S -> Base = (char *)malloc(size);S -> Top = S -> Base;}/*推入一个元素*/void Push(Stack * S,char c){/*栈满了,不能插入了*/if(S -> Top - S -> Base == S -> size) {printf("Stack is full and can't push!"); return;}else{*(++S -> Top) = c;}}void Pop(Stack * S){/*栈空了*/if(S -> Top == S -> Base){printf("Stack is empty!");return;}else{S -> Top--;}}void main(){Stack S;int Begin;char c;CreateStack(&S,100);Begin = 0;while(1){scanf("%c",&c);if(c == '@')break;if(c == '&' && !Begin){Begin = 1;continue;}if(Begin){if(*(S.Top) == c){Pop(&S);}}elsePush(&S,c);}if(S.Top == S.Base){printf("ok\n");}else{printf("fail\n");}getch();}运行结果如下:图中的“ok”表示是回文,“fail”表现不是回文。
实验二栈队列的实现及应用
百度文库-让每个人平等地提升自我实验二栈、队列的实现及应用实验课程名:数据结构与算法专业班级:_ 学号:__________ 姓名: _实验时间: ____ 实验地点:指导教师:冯珊__________一、实验目的1掌握栈和队列的顺序存储结构和链式存储结构,以便在实际背景下灵活运用。
2、掌握栈和队列的特点,即先进后出与先进先出的原则。
3、掌握栈和队列的基本操作实现方法。
/*顺序栈的存储类型*/typedef struct12345远兀1一7U-元谴段囑:>o123R*元元栈書t出一^零遐次:±谨虚123^5I BD 认戯握结IVl 匚on&ol eAp pli cation!\[>ebu g\Con 5 o-leApp li cation1 .exe:1刖人操作谊睪代码(05):2:hEs选的操一兀一b一丁一丁栈?遐次嘆區123455^元元栈S退、灵岀祓SI■i9IIIi主至..T'一兀元栈£12345\Z百度文库-让每个人平等地提升自我P入操隹选择代码(0-5>:4派元素的是;栈化出取示艮i元一一选的操元->入中>c1-苴翻(05):5栈化亍12元元Is务一(2):完成下列程序,该程序实现栈的链式存储结构,构建链栈(栈中的元素依次为China ,Japan, France,India ,Australia ),依次进行进栈和出栈操作,判断栈空和栈满操作,返回栈顶元素操作。
要求生成链栈时,从键盘上读取数据元素。
(1)源代码:#i nclude<>#in clude<>#in clude<># define OK 1# define ERROR 0 typedefchar DataType;/*链式栈的存储类型*/typedef struct SNode丰事元元桟脅化戎孩遊次池谚區12345元元化圍我岀:取示退费出贅-■■-・鼻■--■*・■■\z0 12 3 4 5 1 元元 岀^?取示 退、艮岀读显元一兀 栈 化 S 岀:^£取示 04:读取钱顶元录5湿示貨中匹券 甬只梟祜富i枪祐皿5用—务二:完成下列程序,该程序实现循环队列的 存储和基本操作,构建循环队列,完成键盘缓冲区的功能,每输入一个字符,链入缓冲区队 列中;每输出一个字符,将该字符从缓冲区中删除。
栈和队列基本操作实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求:
堆栈和队列基本操作的编程实现(2学时,验证型),掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】
验证性实验(学时数:2H)
【实验内容】
内容:
把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用,如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【实验分析、说明过程】
【思考问题】
链表存储:通过链表的存储可以实现链表中任意位置的插入元素,删除任意元素,可以实现无序进出。
2.还会有数据移动吗?为什么?
答:栈的顺序存储不会有数据移动,移动的只是指向该数据地址的指针。
3.栈的主要特点是什么?队列呢?
【实验小结】 (总结本次实验的重难点及心得、体会、收获)
【附录-实验代码】。
实验二(1)讲义-栈和队列的应用
实验2:栈和队列的应用
一、实验目的
1.掌握栈的表示与实现
2.掌握队列的表示与实现
3.掌握栈的入栈、出栈等基本操作
4.掌握队列的入队、出队等基本操作
二、实验内容
1.实现顺序栈各种基本运算的算法,具体操作要求如下:
(1)初始化栈,并判断栈是否为空;
(2)对a,b,c,d,f五个字符元素模拟进栈操作;并判断栈是否为空;
(3)取出栈顶元素;
(4)对a,b,c,d,f五个字符元素做依次出栈操作,并判断栈是否为空;
(5)释放栈。
具体效果如下:
注:若sqstack.cpp文件中的方法不合适,可以作修改。
2.实现链栈各种基本运算的算法
(1)初始化栈,并判断栈是否为空;
(2)对a,b,c,d,f五个字符元素模拟进栈操作;并判断栈是否为空;
(3)取出栈顶元素;
(4)对a,b,c,d,f五个字符元素做依次出栈操作,并判断栈是否为空;
(5)释放栈。
注:若listack.cpp文件中的方法不合适,可以作修改。
三、实验要求
1.独立完成实验程序的编写与调试;
2.实验完成后填写实验报告,学习委员按学号从小到大的顺序提交。
四、思考题
1.读入一个有限大小的整数n,然后按输入次序的相反次序输出各元素的值。
(用顺序栈
实现)
2.利用栈完成数制转换。
任意输入一个十进制数,将其转换成八进制数。
(用顺序栈实
现)。
实验二___栈与队列的一个应用
中国计量学院实验报告实验课程:《算法与数据结构》实验名称:栈与队列的一个应用班级: 14计算机1 实验日期:实验目的及要求:一、实验目的1、了解栈和队列的特性2. 掌握栈和队列的顺序表示及实现3. 掌握栈和队列的链式表示及实现4、学会利用栈或队列去求解实际问题二、实验要求从键盘输入包括任意三种括号(即,圆括号()、方括号[]和花括号{})的四则运算(+、-、*、/)表达式,编程判断该表达式的括号是否匹配。
若匹配则计算出表达式的值;若不匹配,则输出“此表达式括号不匹配”。
实验中,假设:(1) 除括号不匹配外,不存在其它非法表达式的情况(2) 表达式中只出现数值常量,不出现变量或符号常量三、实验角色1、Document Writer: ADT设计及实验所涉资料的整理、录入及排版2、Programmer: 算法设计及实现3、Tester: 确定测试用例并负责程序测试,测试用例不少于15种数据结构及关键算法说明这一部分描述解决问题所用到的数据结构及关键算法,可用伪代码、代码或框图表示,目的是让读者在短时间内清楚地理解作者解决问题的整体思路。
因此,表达方式必须比源代码更通俗易懂。
typedef struct SqStack //栈的顺序存储结构{SElemType *base;SElemType *top;int stacksize;}SqStack;char Precede(char a1 ,char a2)//判定运算符的优先级。
{char r;switch(a2){case'+': //此处由于加减几乎优先级一样,故放在一起case'-':if(a1=='('||a1=='['||a1=='{'||a1=='#')r='<';elser='>';break;case'(':if(a1==')'){cout<<"括号匹配错误!"<<endl;exit(-1);}elser='<';break;}//这里只列举加减,左括号。
数据结构实验-线性表及其实现栈和队列及其应用
数据结构实验报告一实验名称:线性表及其实现栈和队列及其应用1 实验目的及实验要求1.线性表目的要求:(1)熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现,以线性表的各种操作(建立、插入、删除等)的实现为实验重点;(2)通过本次实验帮助学生加深对顺序表、链表的理解,并加以应用;(3)掌握循环链表和双链表的定义和构造方法2.栈和队列目的要求:(1)掌握栈和队列这两种特殊的线性表,熟悉它们的特性,在实际问题背景下灵活运用它们;(2)本实验训练的要点是“栈”的观点及其典型用法;(3)掌握问题求解的状态表示及其递归算法,以及由递归程序到非递归程序的转化方法。
2实验内容及实验步骤(附运行结果截屏)1.线性表实验内容:(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。
(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L的有序性;c)(选做)将单链表L逆置并输出;(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。
注:(1)为必做题,(2)~(3)选做。
2.栈和队列实验内容:(1)编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);(2)应用栈的基本操作,实现数制转换(任意进制);(3)编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);(4)利用栈实现任一个表达式中的语法检查(括号的匹配)。
(5)利用栈实现表达式的求值。
注:(1)~(2)必做,(3)~(5)选做。
实验步骤:先编写线性表和栈和队列的类模板,实现各自的基础结构,之后按照要求编写适当的函数方法(公共接口),最后完成封装。
编写主函数直接调用即可。
核心代码://LinearList.h 顺序表//类的声明1.template<class T>2.class LinearList3.{4.public:5.LinearList(int sz = default_size);6.~LinearList();7.int Length()const; //length of the linear8.int Search(T x)const; //search x in the linear and return its order number9.T GetData(int i)const; //get i th order's data10.bool SetData(int i,T x); //change i th order's data to x11.bool DeleteData(int i);12.bool InsertData(int i,T x);13.void output(bool a,int b,int c); //print the linear14.void ReSize(int new_size);15.16.private:17.T *data;18.int max_size,last_data;19.};//构造函数1.template<class T>2.LinearList<T>::LinearList(int sz)3.{4.if(sz>0)5.{6.max_size = sz;st_data=-1;8.data=new T[max_size];9.if(data == NULL)10.{11.cerr<<"Memory creat error!"<<endl;12.exit(1);13.}14.}15.else16.{17.cerr<<"Size error!"<<endl;18.exit(1);19.}20.}//Qlist.h 链式表//模板类的声明1.template<class T>2.struct LinkNode3.{4.T data;5.LinkNode<T> *link;6.LinkNode(LinkNode<T> *ptr = NULL)7.{8.link = ptr;9.}10.LinkNode(const T item,LinkNode<T> *ptr = NULL)11.{12.data = item;13.link = ptr;14.}15.};16.17.template<class T>18.class Qlist: public LinkNode<T>19.{20.public:21.Qlist();22.Qlist(const T x);23.Qlist(Qlist<T>&L);24.~Qlist();25.void MakeEmpty();26.int Length()const; //length of the linear27.int Search(T x)const; //search x in the linear and return its order number28.LinkNode<T> *Locate(int i);29.T GetData(int i); //get i th order's data30.bool SetData(int i,T x); //change i th order's data to x31.bool DeleteData(int i);32.bool InsertData(int i,T x);33.void output(bool a,int b,int c); //print the linear34.35.protected:36.LinkNode<T> *first;37.};//构造函数1.template<class T>2.Qlist<T>::Qlist(Qlist<T>&L)3.{4.T value;5.LinkNode<T>*src = L.getHead();6.LinkNode<T>*des = first = new LinkNode<T>;7.while(src->link != NULL)8.{9.value = src->link->data;10.des->link = new LinkNode<T>(value);11.des = des->link;12.src = src->link;13.}14.des->link = NULL;15.}截屏:3 实验体会(实验遇到的问题及解决方法)刚开始的时候本想先写线性表的类模板然后分别进行继承写顺序表和链式表甚至是以后的栈和队列。
实验报告——栈和队列的应用
实验报告——栈和队列的应用第一篇:实验报告——栈和队列的应用实验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();//调用执行命令的函数,将命令打印并删除}三、程序调试过程中所出现的错误无。
栈和队列的应用实验报告
栈和队列的应用实验报告栈和队列的应用实验报告引言:栈和队列是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。
本实验报告旨在探讨栈和队列的基本概念、特性以及它们在实际应用中的具体使用。
一、栈的基本概念和特性栈是一种特殊的数据结构,它遵循“先进后出”的原则。
栈有两个基本操作:压栈(push)和弹栈(pop)。
压栈将元素添加到栈的顶部,弹栈则将栈顶元素移除。
栈还具有一个重要的特性,即它的访问方式是受限的,只能访问栈顶元素。
在实际应用中,栈可以用于实现递归算法、表达式求值、括号匹配等。
例如,在递归算法中,当函数调用自身时,需要将当前状态保存到栈中,以便在递归结束后能够恢复到正确的状态。
另外,栈还可以用于实现浏览器的“后退”功能,每次浏览新页面时,将当前页面的URL压入栈中,当用户点击“后退”按钮时,再从栈中弹出最近访问的URL。
二、队列的基本概念和特性队列是另一种常见的数据结构,它遵循“先进先出”的原则。
队列有两个基本操作:入队(enqueue)和出队(dequeue)。
入队将元素添加到队列的尾部,出队则将队列头部的元素移除。
与栈不同的是,队列可以访问头部和尾部的元素。
在实际应用中,队列经常用于任务调度、消息传递等场景。
例如,在操作系统中,任务调度器使用队列来管理待执行的任务,每当一个任务执行完毕后,从队列中取出下一个任务进行执行。
另外,消息队列也是一种常见的应用,它用于在分布式系统中传递消息,保证消息的顺序性和可靠性。
三、栈和队列在实际应用中的具体使用1. 栈的应用栈在计算机科学中有广泛的应用。
其中一个典型的应用是表达式求值。
当计算机遇到一个复杂的表达式时,需要将其转化为逆波兰表达式,然后使用栈来进行求值。
栈的特性使得它非常适合处理这种情况,可以方便地保存运算符和操作数的顺序,并按照正确的顺序进行计算。
另一个常见的应用是括号匹配。
在编程语言中,括号是一种常见的语法结构,需要保证括号的匹配性。
数据结构实验2——栈和队列实验报告
数据结构实验报告实验名称:实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
提示:1、可以使用递归或非递归两种方法实现2、实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序:#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数,初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。
栈和队列实验报告
栈和队列实验报告引言:计算机科学中的数据结构是解决问题的关键。
栈和队列这两种常用的数据结构,无疑在许多实际应用中起着重要的作用。
本篇报告旨在探讨栈和队列的实验结果,并展示它们的实际应用。
一、栈的实验结果及应用1. 栈的实验结果在实验中,我们设计了一个基于栈的简单计算器,用于实现基本的四则运算。
通过栈的先进后出(Last In First Out)特性,我们成功实现了表达式的逆波兰表示法,并进行了正确的计算。
实验结果表明,栈作为一个非常有效的数据结构,可以很好地处理栈内数据的存储和检索。
2. 栈的应用栈在计算机科学中有许多实际应用。
其中之一是程序调用的存储方式。
在程序调用过程中,每个函数的返回地址都可以通过栈来保存和恢复。
另一个应用是浏览器的历史记录。
浏览器中每个访问网页的URL都可以通过栈来存储,以便用户能够追溯他们之前访问的网页。
二、队列的实验结果及应用1. 队列的实验结果在实验中,我们模拟了一个简单的出租车调度系统,利用队列的先进先出(First In First Out)特性实现乘客的排队和叫车。
实验结果表明,队列作为一个具有高效性和可靠性的数据结构,能够很好地处理排队问题。
2. 队列的应用队列在许多方面都有应用。
一个常见的应用是消息队列。
在网络通信中,消息队列可以用于存储和传递信息,确保按照特定的顺序进行处理。
另一个应用是操作系统的进程调度。
操作系统使用队列来管理各个进程的执行顺序,以实现公平和高效的资源分配。
三、栈和队列的比较及选择1. 效率比较栈和队列在实际应用中的效率取决于具体问题的需求。
栈的操作更简单,仅涉及栈顶元素的插入和删除,因此具有更高的执行速度。
而队列涉及到队头和队尾元素的操作,稍复杂一些。
但是,队列在某些问题中的应用更为广泛,例如调度问题和消息传递问题。
2. 如何选择在选择栈和队列时,需要根据实际问题的性质和需求进行综合考虑。
如果问题需要追溯历史记录或按照特定顺序进行处理,则应选择栈作为数据结构。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。
在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。
通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。
实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。
在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。
同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。
实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。
在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。
通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。
实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。
在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。
通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。
实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。
在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。
通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。
结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。
实验二--栈和队列其应用
实验二栈和队列其应用题目:利用栈的深度优化进行迷宫求解一、需求分析1、进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法。
2、掌握软件设计的基本内容和设计方法,并培养学生进行规范化软件设计的能力。
3、掌握使用各种计算机资料和有关参考资料,提高学生进行程序设计的基本能力。
1、使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法。
2、使学生掌握软件设计的基本内容和设计方法,并培养学生进行规范化软件设计的能力。
3、使学生掌握使用各种计算机资料和有关参考资料,提高学生进行程序设计的基本能力。
栈和队列其应用目的在于使读者深入了解栈和队列的特性,以便在实际问题背景下灵活运用他们;同时还将巩固对这两种结构的构造方法的掌握,接触较复杂问题的递归算法设计。
(1):算术表达式转波兰表达式和逆波兰表达式(2):栈列操作的验证(建栈、入栈、出栈、销毁栈)(3):判断表达式中括弧是否正确配对(4):队列元素倒置(5):判断字符串是否回文(6):字符串的基本操作(5个基本函数实现)二、概要设计栈和队列及其应用目的在于使读者深入了解栈和队列的特性,以便在实际问题背景下灵活运用他们;同时还将巩固对这两种结构的构造方法的掌握,接触较复杂问题的递归算法设计ADT Stack 的表示和实现#include<malloc.h>#define STACK_INIT_SIZE 30#define STACKINCREMENT 5typedef struct {char * base;char* top;int stacksize;}sqstack;void InitStack(sqstack &s) {s.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));// if(!s.base) exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;}void push(sqstack &s,char &c) {if(s.top-s.base>=s.stacksize) {s.base=(char *) realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));// if(!s.base) exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=c;}void pop(sqstack &s,char &c){if(!(s.top==s.base))c=*--s.top;int stackEmpty(sqstack s){if(s.base==s.top) return(1);return(0);}算术表达式转波兰表达式和逆波兰表达式#include <stdio.h>#include <ctype.h>void transform(char *str,int a[][2],int *n) {int i;*n=1;a[0][0]=1;a[0][1]='(';for (i=0;str[i];){if (isdigit(str[i])){a[*n][0]=0;a[*n][1]=0;while (isdigit(str[i])){a[*n][1]=a[*n][1]*10+str[i]-'0';i++;}}else{if (str[i]=='(') a[*n][0]=1;else if (str[i]==')') a[*n][0]=2;else if (str[i]=='*') a[*n][0]=3;else if (str[i]=='/') a[*n][0]=4;else if (str[i]=='+' || str[i]=='-'){if (i==0 || (!isdigit(str[i-1]) && str[i-1]!=')'))a[*n][0]=0;a[*n][1]=0;(*n)++;}if (str[i]=='+') a[*n][0]=5;else a[*n][0]=6;}a[*n][1]=str[i];i++;}(*n)++;}a[*n][0]=2;a[*n][1]=')';(*n)++;}void poland(int a[][2],int n,int p[][2],int *m) { int i;int stack[1000];//转化所用的栈int depth;//栈的深度depth=0;*m=0;for (i=0;i<n;i++){if (a[i][0]==0) stack[depth++]=i;else if (a[i][0]==1) stack[depth++]=i;else if (a[i][0]==2){while (a[stack[depth-1]][0]!=1){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}depth--;}else if (a[i][0]==3 || a[i][0]==4){while (a[stack[depth-1]][0]==0 || a[stack[depth-1]][0]==3 || a[stack[depth-1]][0]==4){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}stack[depth++]=i;}else if (a[i][0]==5 || a[i][0]==6){while (a[stack[depth-1]][0]!=1){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}stack[depth++]=i;}}}void print_poland(int p[][2],int m) {int i;for (i=0;i<m;i++){if (p[i][0]==0) printf("%d",p[i][1]);else printf("%c",p[i][1]);}putchar('\n');}double evaluate(int p[][2],int m) {double stack[1000];//求值所用的栈int depth;//栈的深度int i;depth=0;for (i=0;i<m;i++){if (p[i][0]==0) stack[depth++]=p[i][1];else{double a,b;b=stack[--depth];a=stack[--depth];if (p[i][0]==3) stack[depth++]=a*b;else if (p[i][0]==4) stack[depth++]=a/b;else if (p[i][0]==5) stack[depth++]=a+b;else stack[depth++]=a-b;}}return stack[0];}int a[1000][2];int n;int p[1000][2];int m;main(){printf("5*(8-2)+9\n");transform("5*(8-2)+9",a,&n);poland(a,n,p,&m);print_poland(p,m);printf("The result of the expression is %lf\n",evaluate(p,m)); return;}判断表达式中括弧是否正确配对#include<iostream.h>#include"sqstack.h"void cmp(sqstack &s,char y,int &state1,int &state2){char x;pop(s,x); //cout<<x;if(s.top==s.base) state1=0;if(x==y) state2=1;else if(x!=y) state2=0;}void main() {sqstack s;InitStack(s);int state1=1,state2;int j=0,flag=1;char n,d[15];for(int i=0;i<15&& state1;i++) {cin>>n;if(int(n)==19) { flag=0;break;}else d[i]=n;char c=d[i];switch(c){case'<': push(s,c);break;case'{': push(s,c);break;case'[': push(s,c);break;case'(': push(s,c);break;case'>': cmp(s,'<',state1,state2); break;case'}': cmp(s,'{',state1,state2); break;case')': cmp(s,'(',state1,state2); break;case']': cmp(s,'[',state1,state2); break;}}if(state2==1) cout<<"good match\n";else cout<<"error match\n";}判断字符串是否回文#include<iostream.h>#include<string.h>#include"qnode.h"#include"sqstack.h"int n=0;void scan(linkqueue &q,sqstack &s){ char k;cin>>k;while(k!='#'){enqueue(q,k);push(s,k);cin>>k;n=n+1;}}void ko(linkqueue &q,sqstack &s){ char c,d;int a,i=1;for(n;n>0;n--){a=daqueue(q,c);pop(s,d);if(c!=d) i=0;}if(i==0) cout<<"no"<<endl;else cout<<"yes"<<endl;}void main(){linkqueue q;sqstack s;initqueue(q);initstack(s);scan(q,s);ko(q,s);}字符串的基本操作#include<stdio.h>#include <string.h>void main (){char s[200];char left[200],right[200];int L,i,j;int N,m=0;char cc[2];printf("Please enter the string\n");fgets(s,199,stdin);L = strlen(s);printf("string L=%d\n",L);printf("Please enter N \n");scanf("%d",&N);if (N < L){strncpy(left,s,N); left[N]='\0';strncpy(right, &s[L-N-1],N); right[N]='\0';printf("left: %s\n",left);printf("right: %s\n",right);} else {printf("left,right: %s\n",s);}printf("Please enter begin location m and N\n");scanf("%d %d",&m,&N);if (m>L) m=0;strncpy(right, &s[m],N); right[N]='\0';printf("mid: %s\n",right);printf("enter a letter:\n");scanf("%s",&cc[0]);printf("Locations: ");for (i=0;i<L;i++) if (s[i]==cc[0]) printf("%d ",i+1);printf("\n");for(i=L-1;i>=0;i--) printf("%c",s[i]);printf("\n");for (i=0;i<L;i++) if (s[i] >= 'a' && s[i] <= 'z') s[i]=s[i]-'a'+'A'; printf("%s\n",s);}栈列操作的验证#include <iostream.h>#include <stdlib.h>typedef int priority;typedef int Status;#define TRUE 1;#define FALSE 0;typedef char elemtype;/*栈元素类型,用链表连接*/ typedef struct node{elemtype chdata;struct node *next;}*pnode;/*定义栈*/typedef struct stack{pnode top;int length;}chstack;/*初始化栈*/void InitStack(stack &s){s.top=NULL; s.length=0;}/*栈不为空,出*/Status Push(stack &s,elemtype e){pnode tem;tem=new node;if(!tem)return FALSE;tem->chdata=e;tem->next=s.top;s.top=tem;s.length++;return TRUE;}/*栈不为空,入*/Status Pop(stack &s,elemtype &e){pnode del;e=s.top->chdata;del=s.top;s.top=s.top->next;delete del;s.length--;return TRUE;}/*做第一个'#'*/void Fstack(stack &s){elemtype e;e='#';if(!Push(s,e))exit(0);}/*取得栈顶元素,e带回*/bool Gettop(stack &s,elemtype &e){ if(s.length>=1) {e=s.top->chdata;return true;} return false;}/*定义优先级,返回*/priority chpri(char e){switch (e) {case '(': return 0;case ')': return 0; case '+': return 1;case '-': return 1;case '*': return 2;case '#': return -1;case '/': return 2;}}bool IsOperator(char e){switch (e) {case '(': break;case ')': break;case '+': break;case '-': break;case '*': break;case '/': break;default: return false;} return true;}/*返回a>=b为真*/bool PriCom(char a,char b){int ai;int bi;ai=chpri(a);bi=chpri(b);return (ai>=bi? true:false);}/*不包括空格,主要转换部分*/void conver(char suff[],char chconver[]){ stack s;char *p;char *psuff;char stacktop;char stackout;InitStack(s);Fstack(s);psuff=suff;p=chconver;while(p!='\0') {if(!IsOperator(*p))*psuff++=*p;else {switch (*p){ case'(': Push(s,*p); break;case')': do{ Gettop(s,stackout);*psuff++=stackout;}while(stacktop!='(');Gettop(s,stackout);*psuff++=stackout;break;default: Gettop(s,stacktop);if( PriCom(*p,stacktop ) )Push(s,*p);while( !PriCom(*p,stacktop) ){ Pop(s,stackout);*psuff++=stackout; }Push(s,*p);}//endswitch}//endelsep++; }//endwhilewhile(stackout!='#') {Gettop(s,stackout);*psuff++=stackout;}}三、详细设计任务:可以输入一个任意大小的迷宫数据,用非递归的方法求出一条走出迷宫的路径,并将路径输出;#include <iostream>#include <fstream>#include <conio.h>using namespace std;struct step //定义一个栈{int x,y,n; //x,y表示步子坐标,n表示步数};void change(char **maze,int hang,int lie){for(int i=0;i<hang+2;i++){for(int j=0;j<lie+2;j++)switch(maze[i][j]){case '1': maze[i][j]='#';break;case '+':case '0':case '.': maze[i][j]=' ';break;}}}void step_to_step(char **maze,step *Step,int hang,int lie,int n){ //单步输出for(int k=0;k<=n;k++){for(int i=0;i<hang+2;i++){for(int j=0;j<lie+2;j++){if(Step[k].x==i&&Step[k].y==j)cout<<"."<<" ";else cout<<maze[i][j]<<" ";}cout<<endl;}cout<<"这是第"<<k+1<<"步"<<endl<<endl;getch();}}void out(char **maze,int hang,int lie,int i,int j) //输出所走的路程{if(i==1&&j==1) //若回到原点则表明无出路{cout<<endl;cout<<"************************************************************" <<endl;cout<<"|-------------此迷宫没有出路,所走路线如下图---------------|"<<endl;cout<<"************************************************************" <<endl;}else //否则有出路{cout<<endl;cout<<"************************************************************" <<endl;cout<<"|----------------找到迷宫出路,如图所示--------------------|"<<endl;cout<<"************************************************************" <<endl;}for(i=0;i<hang+2;i++) //输出步子{for(j=0;j<lie+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}}void cure(char **maze,int hang,int lie){int i=1,j=0,n=-1;char Q;step *Step; //定义一个存储路程的栈Step=new step [hang*lie]; //事先给其分配一定的空间,[hang*lie]表示空间足够if(maze[1][1]=='1'){cout<<"555..我进不去!!!"<<endl<<endl;getch();exit(0);}else while(maze[hang][lie]!='.') //由右、下、左、上的顺序判断是否走通{ //'1'表示走不通,'+'表示已经走过但不通又回来的步子,'.'表示已经走过并通了的步子if(maze[i][j+1]!='1'&&maze[i][j+1]!='.'&&maze[i][j+1]!='+'){if(i==1&&j==0){cout<<"入口"<<endl;}elsecout<<"右"<<endl;maze[i][j+1]='.';j=j+1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i+1][j]!='1'&&maze[i+1][j]!='.'&&maze[i+1][j]!='+'){cout<<"下"<<endl;maze[i+1][j]='.';i=i+1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i][j-1]!='1'&&maze[i][j-1]!='.'&&maze[i][j-1]!='+'){cout<<"左"<<endl;maze[i][j-1]='.';j=j-1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i-1][j]!='1'&&maze[i-1][j]!='.'&&maze[i-1][j]!='+') {cout<<"上"<<endl;maze[i-1][j]='.';i=i-1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else //若走不通则返回上一步{if(i==1&&j==1) //当回到入口时,说明无通路,结束循环break;else{maze[i][j]='+'; //将走不通的点置为+n--;i=Step[n].x; //返回上一个点j=Step[n].y;cout<<"返回"<<endl<<i<<","<<j; //输出返回信息}}if(i==hang&&j==lie)cout<<"(出口)"<<" "<<"(共"<<n+1<<"步"<<")";}out(maze,hang,lie,i,j);cout<<endl<<endl<<endl;cout<<"是否单步输出(y/n):";cin>>Q;cout<<endl<<endl;if(Q=='y'){change(maze,hang,lie);step_to_step(maze,Step,hang,lie,n);}}int main(){char **maze; //定义一个迷宫,空间可动态int hang,lie,i,j;char Q;cout<<"希望手动输入还是文件读入(s:手动输入,w:文件读入):";cin>>Q;cout<<endl<<endl;if(Q=='s'){cout<<"请输入矩阵的行列"<<endl;cout<<"行数:";cin>>hang;cout<<"列数:";cin>>lie;cout<<endl;maze=new char *[hang+2]; //分配连续空间给迷宫for(i=0;i<hang+2;i++)maze[i]=new char [lie+2];cout<<"请输入迷宫,0表示通路,1表示墙"<<endl;for(i=1;i<=hang;i++)for(j=1;j<=lie;j++)cin>>maze[i][j];}else if(Q=='w'){ifstream infile("F:\\migong.txt",ios::in); //可用文件外部输入infile>>hang;infile>>lie;maze=new char *[hang+2]; //分配连续空间给迷宫for(i=0;i<hang+2;i++)maze[i]=new char [lie+2];for(i=1;i<=hang;i++)for(j=1;j<=lie;j++)infile>>maze[i][j];cout<<"文件读取成功!"<<endl;}for(i=0;i<hang+2;i++) maze[i][0]='1';for(i=0;i<lie+2;i++) maze[0][i]='1';for(i=0;i<lie+2;i++) maze[hang+1][i]='1';for(i=0;i<hang+2;i++) maze[i][lie+1]='1';cout<<endl<<endl;cout<<"********************您输入的迷宫为******************************"<<endl;cout<<"行数:"<<hang<<" "<<"列数:"<<lie;cout<<" "<<"入口:"<<"1,1"<<" "<<"出口:"<<hang<<","<<lie<<endl;for(i=0;i<hang+2;i++){for(j=0;j<lie+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}cout<<endl<<endl<<"所走的步骤如下:"<<endl;cure(maze,hang,lie);cout<<endl<<endl<<endl; getch();return 0;}四、运行结果图1运行程序,可以选择输入迷宫的方式:有手动输入和文件输入两种方法可供选择。
数据结构实验报告 栈和队列
2007级数据结构实验报告实验名称:实验二栈和队列日期:2008年11月15日1.实验要求实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力实验内容2.1题目1根据栈和队列的抽象数据类型的定义,按要求实现一个栈或一个队列。
要求:1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构存储结构:特殊线性表:栈,队列栈顶 栈底 链栈2.2 关键算法分析共享栈的入栈算法伪码(Push ): 1.如果栈满,抛出上溢异常。
2.判断是插在栈1还是栈2:2.1如果在栈1插入,则栈顶指针top1加1,在top1处填入元素x ; 2.2如果在栈2插入,则栈顶指针top2加1,在top2处填入元素x 。
共享栈的出栈算法伪码(Pop ):1. 判断是在栈1删除还是在栈2删除。
2. 若是在栈1删除,则2.1 若栈1为空栈,抛出下溢异常; 2.2 删除并返回栈1的栈顶元素;3. 若是在栈2删除,则3.1 若栈2为空栈,抛出下溢异常; 3.2 删除并返回栈2的栈顶元素。
非空链队列 空链队列共享栈的取栈顶元素算法伪码(GetTop):1.判断是在栈1取还是栈2取;2.如果在栈1取,则2.1 若栈1不空,返回栈顶元素的值,不删除;2.2 若栈1空,返回0;3.如果在栈2取,则3.1 若栈2不空,返回栈顶元素的值,不删除;3.2 若栈2空,返回0。
链栈的入栈算法伪码(Push):1.申请一个新的结点,数据域为x;2.将新结点插在栈顶;3.栈顶指针重新指向栈顶元素。
链栈的出栈算法伪码(Pop):1.如果栈空,抛出下溢异常;2.暂存栈顶元素;3.将栈顶结点摘链;4.删除该结点,返回该元素的值。
链栈的取栈顶元素算法的伪码(GetTop):1.如果栈非空,返回栈顶元素的值,不删除。
实验2_栈与队列的应用
实验二:栈与队列的应用学时:4学时实验目的:掌握栈与队列的基本结构和操作方法,并能利用其解决实际问题。
实验内容: (任选一题,有能力的同学可以两题都做)一、输入一个表达式(4+2*4#),利用栈求表达式的值。
(只对整数求值,目前只考虑操作数为个位数的情况,即24+34*34这种情况不考虑)提示:1,先实现栈的基本操作:初始化,入栈,出栈等。
2,首先将一个中缀式变成后缀式,然后,对后缀式求值。
3,可用顺序栈或者链栈实现。
二、编写一个程序,反映病人到医院看病排队看医生的情况,在病人排队过程中,主要重复两件事:(1)病人到达诊室,将病历交给护士,排到等待队列中侯诊(2)护士从等待队列中取出下一位病人的病历,改病人进入诊室就诊要求:模拟病人等待就诊这一过程,程序采用菜单式,其选项和功能说明如下:(1)排队——输入排队病人的病历号,加入到病人排队队列中(2)就诊——病人排队队列中最前面的病人就诊,将其从队列中删除(3)查看排队——从队首到队尾理出所有的排队病人的病历号(4)不在排队,余下依次就诊——从队首到队尾列出所有的排队病人的病历号,并退出运行(5)下班——退出运行(6)上班——初始化排队队列。
提示:1,先实现队列的基本操作:初始化,入队,出队等。
2,在main()程序中,模拟病人看病这个过程。
给出菜单选择,进行相应的操作3,可用顺序队列或者链队列实现。
可参考如下代码:顺序栈的实现ch32_sstack.c#include "stdio.h"#define StackSize 100typedef int ElemType;typedef struct {ElemType elem[StackSize];int top;}SqStack;InitStack(SqStack *pS){pS->top=0; /* top指向栈顶的上一个元素*/}int Push(SqStack *pS,ElemType e){if (pS->top==StackSize-1) /* 栈满*/return 0;pS->elem[pS->top]=e;pS->top=pS->top+1;return 1;}int Pop(SqStack *pS,ElemType* pe){if (pS->top==0) /* 栈空*/return 0;pS->top = pS->top - 1;*pe = pS->elem[pS->top];return 1;}main(){SqStack S;ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}链栈的实现ch3_lstack.c #include "stdio.h"/* 数据元素的类型*/typedef int ElemType;/* 节点的类型(包括头节点)*/typedef struct Node{ElemType elem;struct Node *next;}SNode;/* 初始化,头节点*/InitStack(SNode* pS){pS->next=NULL;}/* 入栈:在头节点之后插入一个新节点*/Push(SNode* pS,ElemType e){SNode* node;node = (SNode*)malloc(sizeof(SNode));node->elem = e;node->next = pS->next;pS->next = node;}int Pop(SNode* pS,ElemType* pe){SNode* node;if (pS->next==NULL){return 0;}*pe = pS->next->elem;node=pS->next;pS->next=node->next;free(node);return 1;}main(){SNode S; ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}队列的顺序实现(循环队列)ch3_squeue.c/*队列的顺序实现(循环队列)author: Shirleydate: 2011.3*/#define MaxSize 100typedef int ElemType;typedef struct {ElemType elem[MaxSize];int front,rear;}SqQueue;InitQueue(SqQueue* pQ){pQ->front=pQ->rear=0;}int EnQueue(SqQueue* pQ,ElemType e){if ((pQ->rear+1)%MaxSize == pQ->front) /* 队满*/ return 0;pQ->elem[pQ->rear] = e;pQ->rear = (pQ->rear+1)%MaxSize;return 1;}int DeQueue(SqQueue* pQ,ElemType* pe){if (pQ->rear == pQ->front) /* 队空*/return 0;*pe = pQ->elem[pQ->front];pQ->front = (pQ->front+1)%MaxSize;return 1;}main(){SqQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}getch();}队列的链式实现ch3_lqueue.c /*队列的链式实现author: Shirleydate: 2011.3*/#include "stdio.h"#define MaxSize 100typedef int ElemType;typedef struct QNode{ElemType elem;struct QNode * next;}QNode;typedef struct {QNode* front;QNode* rear;}LinkQueue;InitQueue(LinkQueue* pQ){QNode* node;node=(QNode*)malloc(sizeof(QNode)); /*分配一个头节点*/ node->next = NULL;pQ->front=pQ->rear=node;}int EnQueue(LinkQueue* pQ,ElemType e){QNode* node;node=(QNode*)malloc(sizeof(QNode));node->elem = e;node->next = NULL;pQ->rear->next = node;pQ->rear = node;return 1;}int DeQueue(LinkQueue* pQ,ElemType* pe){QNode* node;if (pQ->rear == pQ->front) /* 队空*/return 0;node = pQ->front->next;*pe = node->elem;pQ->front->next = node->next;/* 注意有个头节点,当最后一个元素出队时,记得更新尾指针*/ if (pQ->rear==node)pQ->rear=pQ->front;free(node);return 1;}DestoryQueue(LinkQueue* pQ){while(pQ->front){pQ->rear=pQ->front->next;free(pQ->front);pQ->front = pQ->rear;}}main(){LinkQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}DestoryQueue(&Q);getch();}。
2数据结构实验报告二栈和队列及其应用
文档根源为 :从网络采集整理.word 版本可编写 .支持.实验二栈和行列及其应用一、实验目的1.掌握栈和行列这两种抽象数据种类的特色,并能在相应的应用问题中正确采用它们。
2.娴熟掌握栈种类的两种实现方法。
3.娴熟掌握循环行列和链行列的基本操作实现算法。
二、实验内容用行列求解迷宫问题[ 问题描绘 ]以一个 M*N的长方阵表示迷宫, 0 和 1 分别表示迷宫中的通路和墙壁。
设计一个程序,对随意设定的迷宫,求出一条从进口到出口的通路,或得出没有通路的结论。
[ 基本要求 ]实现一个以次序储存构造的行列种类,而后编写一个求解迷宫的非递归途序。
求得的通路以三元组( i ,j ,pre)的形式输出,此中:( i, j)指示迷宫中的一个坐标,pre 表示本路径中上一个方块在行列中的下标。
[ 测试数据 ]由学生随意指定。
三、源代码# include <stdio.h>#define M 5// 行数#define N 5// 列数#define MaxSize 100// 队最多元素个数int mg[M+2][N+2]={// 一个迷宫 , 其周围要加上均为 1 的外框 {1,1, {1,1,1,1,1,1,1},{1,0,0,0,0,0,1},{1,0,1,0,0,1,1},文档根源为 :从网络采集整理.word 版本可编写 .支持.{1,0,1,0,0,1,1},{1,0,1,0,1,0,1},{1,0,0,0,0,0,1},{1,1,1,1,1,1,1}};typedef struct{int i,j;int pre;}Box;typedef struct{Box data[MaxSize];int front, rear;}QuType;void mgpath1(int xi,int yi,int xe,int ye) // 搜寻路径为:( xi ,yi ) ->(xe,ye){void print (QuType qu, int front );int i,j,find=0,di;QuType qu;//定义次序队qu.front=qu.rear=-1;qu.rear++;qu.data[qu.rear].i=xi; //(xi,yi)进队qu.data[qu.rear].j=yi;qu.data[qu.rear].pre=-1;mg[xi][yi]=-1;while(qu.front!=qu.rear&&!find){qu.front++;i=qu.data[qu.front].i;j=qu.data[qu.front].j;if(i==xe&&j==ye){find=1;print(qu,qu.front);}for(di=0;di<4;di++){switch(di){case0:i=qu.data[qu.front].i-1;j=qu.data[qu.front].j;break;case1:i=qu.data[qu.front].i;j=qu.data[qu.front].j+1;break;case2:i=qu.data[qu.front].i+1;j=qu.data[qu.front].j+1;break;case3:i=qu.data[qu.front].i;j=qu.data[qu.front].j-1;break;}if(mg[i][j]==0){find=1;qu.rear++;qu.data[qu.rear].i=i; qu.data[qu.rear].j=j;qu.data[qu.rear].pre=qu.front;mg[i][j]=-1;}}}}void print (QuType qu, int front ){int k=front,j,ns=0;printf("\n");do{j=k;k=qu.data[k].pre;qu.data[j].pre=-1;}while (k!=0);printf(" 迷宫路径以下: \n");k=0;while(k<MaxSize){if(qu.data[k].pre==-1){ns++;printf("\t(%d,%d)",qu.data[k].i,qu.data[k].j);if(ns%5==0)printf("\n");}k++;}printf("\n");}void main(){ mgpath1(1,1,M,N);printf("迷宫全部路径以下 :\n");}四、测试结果:五、心得领会做实验第一要掌握大批的理论知识,而后仔细去达成实验。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二栈、队列的实现及应用
实验课程名:数据结构与算法
专业班级:学号::
/*构造空顺序栈*/
int InitStack(SqStack *S) //InitStack() sub-function
{
S->base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if (!S->base)
{
printf("分配空间失败!\n");
return (ERROR);
}
S->top = S->base;
S->stacksize = STACK_INIT_SIZE;
printf("栈初始化成功!\n");
return (OK);
} //InitStack() end
/*取顺序栈顶元素*/
int GetTop(SqStack *S, SElemType *e) //GetTop() sub-function
{
if (S->top == S->base)
{
printf("栈为空!\n"); //if empty SqStack
return (ERROR);
}
*e = *(S->top - 1);
return (OK);
} //GetTop() end
/*将元素压入顺序栈*/
int Push(SqStack *S) //Push() sub-function
{
SElemType e;
if (S->top - S->base>S->stacksize)
{
S->base = (SElemType *)realloc(S->base, (S->stacksize +
STACKINCREMENT*sizeof(SElemType)));
if (!S->base)
{
printf("存储空间分配失败!\n");
return (ERROR);
}
S->top = S->base + S->stacksize;
S->stacksize += STACKINCREMENT;
}
fflush(stdin);//清除输入缓冲区,否则原来的输入会默认送给变量x
printf("请输入要入栈的元素的值:");
e = getchar();
*S->top++ = e;
return (OK);
} //Push() end
/* 将元素弹出顺序栈*/
int Pop(SqStack *S, SElemType *e) //Pop() sub-function {
if (S->top == S->base)
{
printf("栈为空!\n");
return (ERROR);
}
*e = *--S->top;
return (OK);
} //Pop() end
void display(SqStack *s)
{
if (s->top == s->base)
printf("栈为空!\n");
else{
while (s->top != s->base)
{
s->top = s->top - 1;
printf("%c->", *(s->top));
}
}
printf("\n");
}
int main()
{
int choice;
SElemType e;
SqStack s;
do
{
printf("===============================\n");
printf(" 0:退出\n");
printf(" 1:初始化栈\n");
printf(" 2:入栈\n");
printf(" 3:出栈\n");
printf(" 4:读取栈顶元素\n");
printf(" 5:显示栈中元素\n");
(3)结果分析
顺序表通过设置栈顶运用线性结构实现先进先出功能。
2.任务一(2):完成下列程序,该程序实现栈的链式存储结构,构建链栈(栈中的元素依次为China,Japan,France,India,Australia),依次进行进栈和出栈操作,判断栈空和栈满操作,返回栈顶元素操作。
要求生成链栈时,从键盘上读取数据元素。
(1)源代码:#include<stdio.h>
#include<stdlib.h>
#include<string.h>
# define OK 1
# define ERROR 0
typedef char DataType;
/* 链式栈的存储类型 */
typedef struct SNode //define structure LinkStack
{ DataType data[20];
struct SNode *next;
}SNode,*LinkStack;
void InitStack_L (LinkStack *top)
{
top = (LinkStack)malloc(sizeof(SNode)) ;
top->next = NULL;
printf("\n\n栈初始化成功!\n\n");
}
case '3':Pop_L(&s, e);break;
case '4':GetTop_L(&s, e);printf("栈顶元素的值是:%s\n",e);break; case '5': printf("栈中元素的值是: ");display(&s);
}
}while(choice);
return 0;
}
(2)运行结果
(3)结果分析
链表通过设置栈顶运用指针实现先进先出功能
3.任务二:完成下列程序,该程序实现循环队列的存储和基本操作,构建循环队列,完成键盘缓冲区的功能,每输入一个字符,链入缓冲区队列中;每输出一个字符,将该字符从缓冲区中删除。
(1)源代码:#include<stdio.h>
#include<stdlib.h>
# define MAXQSIZE 100
printf("请输入要入队的字符或字符串,以'#'结束:");
while((e=getchar())!='#')
{
EnQueue(&Q,e);
}
break;
case 2:
DeQueue(&Q,e);
break;
case 3: display(&Q);
}
}while(choice>0&&choice<=3);
return 0;
}
(2)运行结果
(3)结果分析
循环队列通过设置队首和队尾实现先进后出功能
实验总结:
1.在本次试验中我学会了如何实现的栈的顺序存储以及链式存储。
2.以及懂得了栈的基本特性:仅在表尾进行删除和插入操作、先进后出。