实验2栈和队列

合集下载

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

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

实验二 栈和队列实现四则运算一、实验目的及要求:1、掌握栈和队列的基本操作:建立、插入、删除、查找、合并2、掌握用栈和队列的储存3、熟悉C 语言上机编程环境4、掌握编译、调试程序的方法二、实验内容:采用栈进行表达式的求值,表达式求值是程序设计语言编译中的一个最基本问题。

它的实现是栈应用的又一个典型例子,本报告使用的是“算符优先法”求表达式的值。

要把一个表达式翻译成正确求值的一个机器指令序列,或者直接对表达式求值,首先要能够正确解释表达式。

若要正确翻译则首先要了解算术四则运算的规则。

即:(1)、先乘除,后加减; (2)、从左算到右; (3)、先括号内后括号外。

任何一个表达式都是由操作数、运算符和界限符组成的,我们称它们为单词。

一般地,操作数既可以是常数也可以是被说明为变量或常量的标识符;运算符可以分为算术运算符、关系运算符和逻辑运算符3类;基本界限符有左右括号和表达式结束符等。

为了叙述的简洁,我们仅讨论简单算术表达式的求值问题。

这种表达式只包含加、减、乘、除4种运算符。

我们把运算符和界限符统称为算符,它们构成的集合命名为OP 。

根据上述3条运算规则,在运算的每一步中,任意两个相继出现的算符1θ和2θ之间的优先级之多是以下3种关系之一:12θθ< 1θ的优先级低于2θ 12θθ= 1θ的优先级等于2θ 12θθ> 1θ的优先级高于2θ根据实际情况推导出如下的优先关系算符间的优先关系表有规则(3),+、-、*和/为1θ时优先性均低于“(”但高于“),”由规则(2),当12θθ=时,令12θθ>,“#”是表达式的结束符。

为了算法简洁,在表达式左右括号的最左边也虚设了一个“#”构成整个表达式的一对括号。

表中的“(”=“)”表示当左右括号相遇时,括号内的运算已经完成。

同理,“#”=“#”表示整个表达式求值完毕。

“)”与“(、“#”与“)”以及“(”与“#”之间无优先级,这是因为表达式中不允许它们相继出现,一旦遇到这种情况,则可以认为出现语法错误。

实验二 栈和队列

实验二 栈和队列

实验二栈和队列一、实验目的1、掌握栈的结构特性及其入栈,出栈操作;2、掌握队列的结构特性及其入队、出队的操作,掌握循环队列的特点及其操作。

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

要求输入元素序列1 2 3 4 5 e,运行结果如下所示。

#include<stdio.h>#include<malloc.h>#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;S->stacksize=STACK_INT_SIZE;return OK;}/*InitStack*/int Push(SqStack *S,ElemType e){}/*Push*/int Pop(SqStack *S,ElemType *e){}/*Pop*/}/*CreateStack*/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;}void PrintStack(SqStack *S){ElemType e;while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n 1-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题的程序中,编写一个十进制转换为二进制的数制转换算法函数(要求利用栈来实现),并验证其正确性。

实验2 栈和队列的操作

实验2 栈和队列的操作

实验二栈和队列的操作一、实验目的1.熟悉栈和队列的存储结构;2.熟悉栈和队列的相关操作;3.利用栈和队列求解一些常见问题。

二、实验内容1、表达式求值任何一个算术表达式都是由操作数(operand) 、运算符(operator) 和界限符(edlimiter) 组成的。

为了简化问题.这里假设算术表达式中的操作数为单个数字表示的变量:运算符有加“ + ”、减“—”、乘“ * ”、除“/”和括号,表达式以“#”结束。

运算法则是括号优先级最高,先乘除,后加减,同级运算自左至右。

程序设计时需设置两个工作栈。

一个称为运算符栈,用OP 表示,用于存放表达式中的运算符:另一个称为操作数栈,用S 表示,用于存放操作数或运算结果。

这两个栈的初始状态均为空。

计算机从左至右扫描表达式,凡遇操作数一律进S 栈;若遇运算符,则要把它的优先数和栈顶运算符的优先数进行比较:若前者大,则该运算符进OP 栈;否则,栈顶运算符退栈、并进行计算,运算对象为S 栈顶上的两个元素,且先退栈的元素在运算量的右侧,后退栈的在运算量的左侧。

试编写一程序,先输入一个表达式,再求表达式的值。

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

从计算过程可见,这八进制的各个数位产生的顺序是从低位到高位的,而打印输出的顺序,一般来说应从高位到低位,这恰好和计算过程相反。

因此,需要先保存在计算过程中得到的八进制数的各位,然后逆序输出,因为它是按“后进先出”的规律进行的,所以用栈最合适。

试编写一个程序,实现将十进制数转换成八进制数并输出。

三、主要任务1、完成算法设计和程序设计,并分析算法时间复杂度和空间复杂度;2、写出程序运行情况,写出输入数据及运行结果;3、撰写实验报告,写出算法设计小结和心得。

四、思考题1、为什么说栈是一种特殊线性表?它的操作与线性表有什么不同?2、对于数制转换算法,如果不用栈如何实现?。

实验二栈和队列

实验二栈和队列
[实现提示]
需另设一个栈,临时停放为给要离去的汽车让路而从停车场退出来的汽车,也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车,包含两个数据项:汽车的牌照号码和进入停车场的时刻。
[选作内容]
(1)两个栈共享空间,思考应开辟数组的空间是多少?
(2)汽车可有不同种类,则它们的占地面积不同,收费标准也不同,如1辆客车和1.5辆小汽车的占地面积相同,1辆十轮卡车占地面积相当于3辆小汽车的占地面积。
实验条件:
实验内容:
1.采用链式存储实现栈的初始化、入栈、出栈操作。
2.采用顺序存储实现栈的初始化、入栈、出栈操作。
3.采用链式存储实现队列的初始化、入队、出队操作。
4.采用顺序存储实现循环队列的初始化、入队、出队操作。
5.在主函数中设计一个简单的菜单,分别测试上述算法。
*6.综合训练:1)利用栈实现表达式求值算法。
洛阳理工学院实验报告
系别
班级
学号
姓名
课程名称
实验日期
实验名称
实验二、栈和队列的应用
成绩
实验目的:
1、掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。
2、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,队列顺序存储结构、链式存储结构和循环队列的实现,以便在实际问题背景下灵。
(3)汽车可以直接从便道上开走,此时派在它前面的汽车要先开走让路,然后再依次排到队尾。
(4)停放在便道上的汽车也收费,收费标准比停放在停车场的车低,请思考如何修改结构以满足这种要求。
实验总结:
[测试数据]
设n=2,输入数据为:(‘A’,1,5),(‘A’,2,10),(‘D’,1,15),(‘A’,3,20),(‘A’,4,25),(‘A’,5,30),(‘D’,2,35),(‘D’,4,40),(‘E’,0,0)。其中,‘A’表示到达;‘D’表示离去,‘E’表示输入结束。

实验二 栈和队列

实验二 栈和队列

实验二栈和队列本文档旨在介绍实验二的目的和背景,以及本实验的重要性。

实验二主要涉及栈和队列的相关概念和操作。

栈和队列是常用的数据结构,它们在计算机科学和软件开发中起着重要的作用。

栈是一种先进后出(Last In First Out,LIFO)的数据结构,类似于我们平常堆放书籍的行为。

队列是一种先进先出(First In First Out,FIFO)的数据结构,类似于排队等待的情景。

通过本实验,我们将研究如何使用栈和队列来解决各种问题。

掌握栈和队列的基本原理和操作,对于提高程序的效率和优化算法都具有重要意义。

同时,栈和队列的概念也是许多其他数据结构和算法的基础,理解栈和队列将有助于我们更深入地研究和应用其他数据结构和算法。

本实验将引导我们通过实际的编程练来加深对栈和队列的理解和应用。

我们将实现栈和队列的基本操作,例如入栈、出栈、入队、出队等,并通过一系列的例子和问题来巩固对这些概念的理解。

通过完成本实验,我们将掌握栈和队列的基本概念和操作,加深对其应用场景的理解和掌握,并培养解决问题的逻辑思维能力和编程实践能力。

让我们开始实验二的研究,进一步探索栈和队列的奥秘吧!本实验的目标是研究和理解栈和队列数据结构的基本概念和操作。

本实验主要涉及栈和队列的定义、基本操作及其应用。

栈的定义栈是一种具有后进先出(Last-In-First-Out,简称LIFO)特性的线性数据结构。

栈只允许在表尾(称为栈顶)进行插入和删除操作,且最后插入的元素最先删除。

栈的基本操作栈的基本操作包括:Push:将元素插入到栈顶。

Pop:删除栈顶的元素,并返回被删除的元素。

IsEmpty:判断栈是否为空。

Top:返回栈顶的元素,但不删除栈顶元素。

栈的应用栈在计算机科学中有广泛的应用,包括但不限于:函数调用(函数调用时的局部变量保存在栈中)。

表达式求值(后缀表达式计算等)。

浏览器的页面回退功能。

队列的定义队列是一种具有先进先出(First-In-First-Out,简称FIFO)特性的线性数据结构。

天大数据结构_实验作业二_栈(顺序栈)+队列(循环队列)

天大数据结构_实验作业二_栈(顺序栈)+队列(循环队列)

实验作业二:栈(顺序栈)和队列(循环队列)1. 将编号为0和1的两个栈存放于一个数组空间V[m]中,栈底分别处于数组的两端。

当第0号栈的栈顶指针top[0]等于-1时该栈为空,当第1号栈的栈顶指针top[1]等于m时该栈为空。

两个栈均从两端向中间增长。

当向第0号栈插入一个新元素时,使top[0]增1得到新的栈顶位置,当向第1号栈插入一个新元素时,使top[1]减1得到新的栈顶位置。

当top[0]+1 == top[1]时或top[0] == top[1]-1时,栈空间满,此时不能再向任一栈加入新的元素。

试定义这种双栈(Double Stack)结构的类定义,并实现判栈空、判栈满、插入、删除算法。

2. 求fibonacci数列算法,并比较。

(递归+非递归)(非递归方法可查阅其他资料)编写实习报告要求:一、需求分析二、概要设计1.抽象数据类型2.算法三、详细设计程序代码(注释)四、调试分析调试过程中所做的工作,时间复杂度等五、测试结果输入数据和输出数据示例六、说明(如果有)编程语言:C语言或C++语言实习报告提交方式:下次上机前,将实习报告(.doc)和源程序(.cpp)压缩成一个rar 文件,文件名称为学号_班级_姓名_第几次作业。

例如:3010216155_六班_张三_第二次作业.rar。

实习报告作为本课程的平时成绩。

抄袭、雷同,双方均为0分。

第一题:一、需求分析程序要求建立一个共享栈,分配一个存储空间,两个栈分别位于两头。

并实现对两个栈的插入,删除,和判断栈满和栈空。

栈的位置不同,所以要求对不同栈的插入和删除采用不同的算法。

二、概要设计1.抽象数据类型typedef struct {int *base;int *top;int stacksize;}stack;2.算法1.建立栈。

int instack(stack &s,stack &w,int length){s.base=(int *)malloc(length*sizeof(length));w.base=s.base+length;if(!s.base||!w.base) return 0;else{s.top=s.base;w.top=w.base;s.stacksize=length;w.stacksize=length;}return 1;}2.判断栈空。

栈和队列的基本操作实验报告

栈和队列的基本操作实验报告

《数据结构》实验报告一软件132201300514211徐蜀实验二栈和队列的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应用。

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

3、掌握栈和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。

二、实验内容1.回文判断三、实验要求1、按照数据结构实验任务书,提前做好实验预习与准备工作。

2、加“*”题目必做,其他题目任选;多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范,及时完成实验报告。

四、实验步骤(说明:依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作(函数)的伪码算法、函数实现、程序编码、调试与分析。

附流程图与主要代码)㈠、数据结构与核心算法的设计描述(程序中每个模块或函数应加注释,说明函数功能、入口及出口参数)1、栈的初始长度与需要再增加的长度#define STACK_INIT_SIZE 100;#define STACKINCREMENT 10;typedef char SElemType;//定义SElemType为char型2、栈的顺序存储表示typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;3、队列的链式表示方法typedef struct QNode {SElemType data;struct QNode *next; } QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4、初始化栈/* 函数功能:对栈进行初始化参数:栈(SqStack &S)成功返回1,否则返回0 */int InitStack(SqStack &S){S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));//申请内存if(!S.base) //判断有无申请到空间return ERROR; //没有申请到内存,返回0S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}5、入栈操作/* 函数功能:将元素入栈参数:栈(SqStack &S),插入元素e插入成功返回1,否则返回0 */int Push(SqStack &S, SElemType e){if(S.top - S.base >= S.stacksize) //判断栈顶与栈底的差是否大于栈的//容量{S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType)); //栈满了,重新申请内存if(!S.base) //判断是否申请成功return ERROR; //不成功返回0S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}6、出栈操作/* 函数功能:将栈中的元素弹出参数:栈(SqStack &S),记录元素e */int Pop(SqStack &S, SElemType &e){if(S.top == S.base) //判断栈是否为空return ERROR;e = *(--S.top) ;return OK;}7、初始化队列/* 函数功能:初始化队列参数:队列(LinkQueue &Q)成功返回1,否则返回0 */int InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));//申请结点的内存if(!Q.front) //判断有无申请到空间return ERROR; //没有返回0Q.front ->next = NULL;return OK;}8.在队列队尾插入元素/* 函数功能:在队列队尾插入元素参数:队列(LinkQueue &Q),插入元素e成功返回1,否则返回0 */ int EnQueue(LinkQueue &Q, QElemType e){p = (QueuePtr)malloc(sizeof(QNode)); //申请新的结点if(!p)return ERROR;p -> data = e;p -> next = NULL;Q.rear -> next = P;Q.rear = p;return OK;}9.删除队头元素/* 函数功能:删除对头元素参数:队列(LinkQueue &Q),记录值e成功返回1,否则返回0 */ int DeQueue(LinkQueue &Q, QElemType &e){if(Q.front == Q.rear) //判断队列是否为空return ERROR;p = Q.front -> next;e = p -> data;Q.front -> next = p -> next;if(Q.rear == p)Q.rear = Q.front;free(p);return OK;}10、主函数int main(){SqStack S; //声明一个栈LinkQueue Q; //声明一个队列char m,k,c;int n=0,i,j,t=0,z=0;while(!t){cout << "请输入你要判断回文的字符串,输入@结束:";InitQueue (Q);InitStack (S);while((c=getchar())!='@')//对字符的判断不断输入字符{EnQueue (Q,c);Push (S,c);n++;}for( j=1;j<=n;j++){OutQueue (Q,m);Pop (S,k);if(m!=k)break;}if(j>n) //如果j > n则说明全部相等cout << "这个字符串不是回文字符串" << endl;elsecout << "这个字符串是回文字符串" << endl;}return 0;}说明:通过调用序列号不同的函数进行各种操作。

数据结构实验二

数据结构实验二

数据结构实验二数据结构实验二:队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构,加深对队列和栈实现原理的理解,并熟练掌握队列和栈的基本操作。

二、实验要求1.使用C/C++语言实现队列的基本操作:初始化队列、入队、出队、判空、判满等。

2.使用C/C++语言实现栈的基本操作:初始化栈、入栈、出栈、判空、判满等。

3.验证队列和栈的实现是否正确。

4.分析队列和栈的时间复杂度,并给出实验结果。

5.撰写实验报告,包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。

三、实验原理1.队列:队列是一种先进先出(FIF0)的数据结构。

在队列中,数据元素按照进入队列的顺序排列,首元素是最先进入的元素,尾元素是最后进入的元素。

队列的基本操作有:初始化队列、入队、出队、判空、判满等。

2.栈:栈是一种后进先出(LIFO)的数据结构。

在栈中,数据元素按照进入栈的顺序排列,但是只能从栈顶进出,即最后进入的元素最先出栈。

栈的基本操作有:初始化栈、入栈、出栈、判空、判满等。

四、实验步骤1.实现队列的基本操作:1.初始化队列:创建一个空队列,并设置相关指针。

2.入队:将新元素插入到队尾。

3.出队:将队头元素删除,并返回其值。

4.判空:判断队列是否为空。

5.判满:判断队列是否已满。

2.实现栈的基本操作:1.初始化栈:创建一个空栈,并设置相关指针。

2.入栈:将新元素压入栈顶。

3.出栈:将栈顶元素弹出,并返回其值。

4.判空:判断栈是否为空。

5.判满:判断栈是否已满。

3.编写测试代码,验证队列和栈的基本操作是否正确。

4.进行性能测试,分析队列和栈的时间复杂度。

五、实验结果与分析1.队列的时间复杂度:●初始化队列:O(1)●入队:O(1)●出队:O(1)●判空:O(1)●判满:O(1)2.栈的时间复杂度:●初始化栈:O(1)●入栈:O(1)●出栈:O(1)●判空:O(1)●判满:O(1)3.根据实验结果可以看出,队列和栈的基本操作的时间复杂度都是O(1),即常数时间复杂度,具有高效性。

实验二 栈和队列

实验二 栈和队列

实验二栈和队列一、实验目的1. 掌握栈的顺序表示和实现2. 掌握队列的链式表示和实现二、实验内容1. 编写一个程序实现顺序栈的各种基本运算。

2. 实现队列的链式表示和实现。

三、实验步骤1. 初始化顺序栈2. 插入元素3. 删除栈顶元素4. 取栈顶元素5. 遍历顺序栈6. 置空顺序栈7. 初始化并建立链队列8. 入链队列9. 出链队列10. 遍历链队列四、实现提示1. /*定义顺序栈的存储结构*/typedef struct {ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序栈函数*/void InitStack(SqStack *p){q=(SqStack*)malloc(sizeof(SqStack) /*申请空间*/) /*入栈函数*/void Push(SqStack *p,ElemType x){if(p->top<MAXNUM-1){p->top=p->top+1; /*栈顶+1*/p->stack[p->top]=x; } /*数据入栈*/}/*出栈函数*/ElemType Pop(SqStack *p){x=p->stack[p->top]; /*将栈顶元素赋给x*/p->top=p->top-1; } /*栈顶-1*//*获取栈顶元素函数*/ElemType GetTop(SqStack *p){ x=p->stack[p->top];}/*遍历顺序栈函数*/void OutStack(SqStack *p){ for(i=p->top;i>=0;i--)printf("第%d个数据元素是:%6d\n",i,p->stack[i]);} /*置空顺序栈函数*/void setEmpty(SqStack *p){ p->top= -1;}2. /*定义链队列*/typedef struct Qnode{ ElemType data;struct Qnode *next;}Qnodetype;typedef struct{ Qnodetype *front;Qnodetype *rear;}Lqueue;/*初始化并建立链队列函数*/void creat(Lqueue *q){ h=(Qnodetype*)malloc(sizeof(Qnodetype)); /*初始化申请空间*/ h->next=NULL;q->front=h;q->rear=h;for(i=1;i<=n;i++)*利用循环快速输入数据*/{ scanf("%d",&x);Lappend(q,x);} /*利用入链队列函数快速输入数据*/}/*入链队列函数*/void Lappend(Lqueue *q,int x){ s->data=x;s->next=NULL;q->rear->next=s;q->rear=s;}/*出链队列函数*/ElemType Ldelete(Lqueue *q){ p=q->front->next;q->front->next=p->next;if(p->next==NULL)q->rear=q->front;x=p->data;free(p);} /*释放空间*//*遍历链队列函数*/void display(Lqueue *q){ while(p!=NULL) /*利用条件判断是否到队尾*/{ printf("%d-->",p->data);p=p->next;}}五、思考与提高1. 读栈顶元素的算法与退栈顶元素的算法有何区别?2. 如果一个程序中要用到两个栈,为了不发生上溢错误,就必须给每个栈预先分配一个足够大的存储空间。

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

数据结构实验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<<"种摆放方法。

栈和队列基本操作实验报告

栈和队列基本操作实验报告

栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(2学时,验证型),掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】验证性实验(学时数:2H)【实验内容】内容:把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。

可以实验一的结果自己实现数据输入、数据显示的函数。

利用基本功能实现各类应用,如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。

【实验分析、说明过程】分析:进栈操作先创建一个以x为值的新结点p,其data域值为x则进栈操作步骤如下: 将新结点p的指针域指向原栈顶S(执行语句p->next=S)。

将栈顶S指向新结点p(执行语句S=p)。

注:进栈操作的?与?语句执行顺序不能颠倒,否则原S指针其后的链表将丢失。

出栈操作先将结点栈顶S数据域中的值赋给指针变量*x,则删除操作步骤如下: 结点p 指针域指向原栈顶S(执行语句p=S)。

栈顶S指向其的下一个结点(执行语句S=S->next)释放p结点空间(执行语句free(p))。

队列分析:用链式存储结构实现的队列称为链队列,一个链队列需要一个队头指针和一个队尾指针才能唯一确定。

队列中元素的结构和前面单链表中的结点的结构一样。

为了操作方便,在队头元素前附加一个头结点,队头指针就指向头结点。

【思考问题】1. 栈的顺序存储和链表存储的差异,答:栈的顺序存储有‘后进先出’的特点,最后进栈的元素必须最先出来,进出栈是有序的,在对编某些需要按顺序操作的程序有很大的作用。

链表存储:通过链表的存储可以实现链表中任意位置的插入元素,删除任意元素,可以实现无序进出。

2. 还会有数据移动吗,为什么,答:栈的顺序存储不会有数据移动,移动的只是指向该数据地址的指针。

(数据结构)实验2 堆栈与队列

(数据结构)实验2  堆栈与队列

实验2 堆栈与队列
实验目的
1.会定义顺序栈和链栈的结点类型。

2.掌握栈的插入和删除结点在操作上的特点。

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

4.会定义顺序队列和链队列的结点类型。

实验内容
程序1 舞伴问题
(1)问题描述
假设在周末舞会上,男士和女士进入舞厅时,各自排成一队。

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

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

编写程序模拟上述舞伴配对问题。

(2)问题分析
根据问题描述可知,新来人员将根据性别分别在队尾插入到男队或女队。

排在队头的男士或女士优先出队,并与另一个队中的队头成员组成舞伴。

由此可见,舞伴问题中的成员关系存在着先进先出的特点,可以采用队列这种数据结构来存储两队信息。

舞伴问题中,不断有队头成员出队组成新的舞伴及新成员在队尾插入的操作,如果采用的顺序队列,由于队头元素删除后,存储空间的不可重复操作性,将导致存储空间浪费,从而造成假溢出现象的发生。

根据以上分析,采用循环队列进行存储。

程序2回文数
由于输入的一个回文数可能无穷大,所以要求使用单链表存储该数。

[问题描述]
将用户输入的数以一个单链表的方式存储。

从头扫描该单链表,将前面的一半元素入栈,若元素的总个数为奇数,则跳过中间的那个元素,然后开始循环:边退栈边在单链表中后移指针,若当前栈顶元素与单链表中当前节点的值域不相等,则退出循环。

最后如果栈空且链表比较完毕,则是回文数,否则不是回文数。

实验二 栈和队列的算法实现

实验二  栈和队列的算法实现
实验二 栈和队列的算法实现
1、实验目的

(1)熟练掌握栈和队列的结构,以及这两种数据
结构的特点;

(2)能够在两种存储结构上实现栈的基本运算,
特别注意栈满和栈空的判断条件及描述方法;

(3)熟练掌握链队列和循环队列的基本运算,并
特别注意队列满和队列空的判断条件和描述方法;
2、实验要求:


(1) 给出程序设计的基本思想、原理和算法描述。
(2)只要X不为0重复做:将X%R入栈、X=X/R
(3)只要栈不为空重复做:栈顶出栈、输出栈顶元素
4、实验步骤
(1)理解循环链表的基本实验原理;
(2)仔细分析实验内容,给出其算法和流程图; (3)用C或C++语言实现该算法; (4)给出测试数据,并分析其结果; (5)在实验报告册上写出实验过程。
课后作业
(2) 对源程序给合程序进行分析。
3、实验内容 利用栈的基本操作将一个十进制的正整数转换成二进 制数据,并将其转换结果输出。 提示:利用栈的基本操作实现将任意一个十进制整数 转化为R进制整数,算法为: 1)定义栈的顺序存取结构 2)分别定义栈的基本操作(初始化栈、判栈为空、出栈、入 栈等) 3) 定义一个函数实现上面问题:十进制整数X和R作为形参 (1)初始化栈

(1) 利用栈的基本操作对给定的字符串判断其是否 是回文,若是则输出“Right”,否则输出
“Wrong”。

(2) 假设循环队列中只设rear和quelen来分别表示
队尾元素的位置和队中元素的个数,写出相应的入
队和出队程序。
实验报告要求 《数据结构》实验报告要求.doc

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

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

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.如果栈非空,返回栈顶元素的值,不删除。

实验二_栈与队列的基本操作与实现

实验二_栈与队列的基本操作与实现

实验二栈与队列的基本操作与实现一、实验目的:利用高级程序设计语言来实现抽象数据类型栈与队列,进一步熟悉其表示和实现方法,用已经实现的操作来组合新的操作,为以后的利用栈和队列分析和解决问题打下基础。

1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应用。

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

3、掌握栈和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。

二、实验要求:1、定义栈的抽象数据类型,并用顺序栈或链栈实现其基本操作:初始化,判断栈空、栈满,出栈、入栈,取栈顶元素等2、定义队列的抽象数据类型,构造循环队列实现其基本操作:初始化,判断队空、队满,出队、入队等3、编写和调试完成程序4、保存和打印程序的运行结果三、测试数据字符的序列为ABCDEFG执行进出栈的次序为:XXYXXYYXXXY(其中X表示进栈,Y表示出栈)栈中的元素为:AEF执行进出队的次序为:XXYXXYYXXXY(其中X表示进队,Y表示出队)栈中的元素为:EFG四、实现提示:1、栈与队列可以用数组进行存储,并定义为全局变量,以减少函数调用时参数的传递。

(即在函数体外面定义变量,全局变量可以为本文件中其他函数所共用,其有效范围为从定义变量的位置开始到本源文件结束)栈:#define MAXN 26char stack[MAXN];int top=0;队列:#define MAXN 26char q[MAXN];int head = 0, tail = 0;2、主控函数示例:void main(){int n,x1,x2,select;char x,y;printf("input a stack length(1<=n<=26)):\n");scanf("%d",&n);printf("select 1:Display()\n");//显示栈中的元素printf("select 2:Push()\n");//进栈printf("select 3:Pop()\n");//出栈printf("select 4:StackTop()\n");//取出栈顶的元素,但并不出栈printf("select 0:exit\n");//退出printf("input a your select(0-4):\n");scanf("%d",&select);while(select!=0){switch(select){ case 1: Display();break;case 2: printf("input a push a value:\n");scanf("%c",&x);scanf("%c",&y);Push(x);break;case 3: x1=Pop();printf("x1->%d\n",x1);break;case 4: x2=StackTop();printf("x2->%d",x2);break;}printf("select 1:Display()\n");printf("select 2:Push()\n");printf("select 3:Pop()\n");printf("select 4:StackTop()\n");printf("select 0:exit");printf("input a your select(0-4):\n");scanf("%d",&select);}}3、队列基本操作的实现与栈类似,可以分开写,也可以写在一个主函数中。

2数据结构实验报告二(栈和队列及其应用)

2数据结构实验报告二(栈和队列及其应用)

实验二 栈和队列及其应用、实验目的1. 掌握栈和队列这两种抽象数据类型的特点,并能在相应的应用问题中正 确选用它们。

2. 熟练掌握栈类型的两种实现方法。

3. 熟练掌握循环队列和链队列的基本操作实现算法。

二、实验内容用队列求解迷宫问题[ 问题描述 ]以一个M*N 的长方阵表示迷宫,0和1分别表示迷宫中的通路和墙壁。

设计 一个程序, 对任意设定的迷宫, 求出一条从入口到出口的通路, 或得出没有通路 的结论。

[ 基本要求 ]实现一个以顺序存储结构的队列类型, 然后编写一个求解迷宫的非递归程序。

求得的通 路以三元组(i ,j ,pre )的形式输出,其中:(i ,j )指示迷宫中的一个坐标,径中上一个方块在队列中的下标。

三、源代码# include <stdio.h>{1,1,1,1,1,1,1}, {1,0,0,0,0,0,1}, {1,0,1,0,0,1,1},pre 表示本路[ 测试数据 ] 由学生任意指定。

#define M 5// #define N 5// 行数 列数 #define MaxSize 100// int mg[M+2][N+2]={// 队最多元素个数 一个迷宫 , 其四周要加上均为 1 的外框 {1,1,{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 {inti,j;int pre;}Box; typedef struct{Boxdata[MaxSize];int front, rear;}QuType;void mgpath1(int xi,int yi,intxe,int ye) // ->(xe,ye) { void print (QuType qu, int front );搜索路径为:( xi ,yi ) inti,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");四、测试结果:文档来源为:从网络收集整理.word 版本可编辑.欢迎下载支持.做实验首先要掌握大量的理论知识,大的困难,这就要需要我们的毅力。

实验2_栈与队列的应用

实验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();}。

数据结构实验——栈和队列

数据结构实验——栈和队列

2008级数据结构实验报告实验名称:实验二——栈和队列学生姓名:班级:班内序号:学号:日期:2009年11月7日1.实验要求根据栈和队列的抽象数据类型的定义,按要求实现一个栈或一个队列。

要求:1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构2.1.1共享栈2.1.2链栈2.2 关键算法分析2.2.1共享栈开辟一个空间,两个栈共享。

top1和top2分别为栈1和栈2的栈顶指针。

Stack_Size为整个数组空间的大小;栈1的底固定在下标为0的一端;栈2的底固定在下标为StackSize-1的一端。

如果是压栈,则栈1的top1加1,栈2的top2减1;如果是出栈,则栈1的top1减1,栈2的top2加1。

压栈: 1、如果栈满,则抛出上溢异常;2、判断是插在栈1还是栈2;2.1 若是在栈1插入,则栈顶指针top1加1,在top1处填入x;2.1 若是在栈2插入,则栈顶指针top2减1,在top2处填入x;时间复杂度为O(1)出栈:1、判断是在栈1删除还是在栈2删除。

2、若是在栈1删除,则2.1 若栈1为空栈,抛出下溢异常;2.2 删除并返回栈1的栈顶元素;3、若是在栈2删除,则3.1 若栈2为空栈,抛出下溢异常;3.2 删除并返回栈2的栈顶元素;时间复杂度为O(1)2.2.2链栈链栈在压栈的时候先创造一个新的结点,将要加入的元素作为它的元素。

将top->next 指向这个新的结点。

top指向这个新的结点。

在出栈的时候,先构造一个工作节点,把当前的栈顶结点赋给它。

将栈顶结点摘链,并释放工作结点。

压栈:1、工作指针p初始化;2、生成一个元素值为x的新结点;3、将新结点s插入到结点p之后;时间复杂度为O(1)出栈:1、判断链栈是否为空;2、工作指针初始化;3、x暂存被删元素值;4、top下移;5、释放工作指针;时间复杂度为O(1)3.程序运行结果3.1共享栈链栈:4. 总结1、通过实验知道了,如果时两个数据类型相同的栈,可以公用一个数组来节约内存空间。

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

江南大学通信与控制工程学院标准实验报告
(实验)课程名称:计算机软件技术基础实验名称:栈和队列
班级:自动化
姓名:李玉书
学号:0704090303
指导教师:卢先领
江南大学通信与控制学院
江南大学
实验报告
学生姓名:曹劼学号:0704080123
实验地点:信控机房实验时间:90分钟
一、实验室名称:信控学院计算中心
二、实验项目名称:栈和队列
三、实验学时:4学时
四、实验原理:
用栈实现顺序表的操作
五、实验目的:
1、掌握栈的数据类型描述,栈的特点及栈的存储结构;
2掌握栈的基本运算及应用。

六、实验内容:
设车辆厂生产了硬座车厢和软座车厢共N节,混合在一起要求用顺序栈的5种运算使所有的硬座车厢排列到软座车厢前面。

请完善主函数实现上述功能。

七、实验器材(设备、元器件):
计算机
八、实验步骤:
1、输入示例程序
2、构建按序插入函数实现算法
3、用C语言实现该算法
4、与源程序合并,编译,调试
5、测试,查错,修改
6、生成可执行文件,通过综合测试,完成实验
九、实验数据及结果分析:
测试用例
车厢数5,初始顺序SSHSH 测试结果
十、实验结论:
该程序能够判断是否输入错误,并且能够对正确情况下进行栈的数据处理,但是占用了额外的储存量,并且计算次数过多。

并且函数不具有通用性。

十一对本实验过程及方法、手段的改进建议:
完善了主函数的功能,使其能够达到排序的目的,但是浪费了一个数组的空间量和运算次数多。

附:源程序
报告评分:
#include<iostream.h>
#include<stdio.h>
#define elemtype char
const int maxlen=20;
typedef struct
{
elemtype stack[maxlen];
int top;
}seqstack;
//栈初始化
void inistack(seqstack &s)
{
s.top=-1;
}
//进栈
void push(seqstack &s,elemtype x)
{
if(s.top==maxlen-1)cout<<"overflow";
else
{
s.top++;
s.stack[s.top]=x;
}
}
//出栈
void pop(seqstack &s)
{
if(s.top==-1)cout<<"underflow";
else
{
s.top--;
}
}
//取栈顶元素
elemtype getton(seqstack s)
{
if(s.top==-1){cout<<"underflow";return 0;}
else return s.stack[s.top];
}
//判栈空
int empty(seqstack s)
{
if(s.top==-1)return 1;
else return 0;
}
//打印栈内容
void prtstack(seqstack &s)
{
int i;
for(i=0;i<=s.top;i++)cout<<s.stack[i]<<endl;
}
//按序入栈
void sortstack(seqstack &s,int &n)
{
elemtype x;
while(0==n--||maxlen-1==s.top)return; //n次后或堆栈满时,递归结束while(!(('H'==(x=getchar()))||('S'==x))); //接受H或S,过滤无关量
if('H'==x)push(s,x); //H优先压栈
sortstack(s,n);
if('S'==x)push(s,x); //H全入栈后,S入栈
}
void main(void)
{
int n,i;
elemtype x;
seqstack s;
inistack(s);
cout<<"请输入车厢数";
cin>>n;
cout<<"请输入"<<n<<"节车厢代号(H代表硬座车厢,S代表软座车厢)"<<endl; sortstack(s,n);
prtstack(s);
} 指导教师签字:。

相关文档
最新文档