北京信息科技大学数据结构实验二链栈,循环队列和计算器的操纵
数据结构实验指导书(C++)-栈、队列、串的操作
![数据结构实验指导书(C++)-栈、队列、串的操作](https://img.taocdn.com/s3/m/4bebfb5ca517866fb84ae45c3b3567ec102ddca1.png)
数据结构实验指导书(C++)-栈、队列、串的操作实验二栈、队列、串的操作实验类型:验证性实验要求:必修实验学时: 2学时一、实验目的:参照给定的栈类和队列类的程序样例,验证给出的栈和队列的常见算法,并结合线性表类实现有关串的操作。
二、实验要求:1、掌握栈、队列、串的特点。
掌握特殊线性表的常见算法。
2、提交实验报告,报告内容包括:目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。
三、实验内容:1. 堆栈类测试和应用问题。
要求:(1)设计一个主函数实现对顺序堆栈类和链式堆栈类代码进行测试。
测试方法为:依次把数据元素1,2,3,4,5入栈,然后出栈堆栈中的数据元素并在屏幕上显示。
(2)定义数据元素的数据类型为如下形式的结构体:typedef struct{ char taskname[10];//任务名int taskno; //任务号}DataType;设计一个包含5个数据元素的测试数据,并设计一个主函数实现依次把5个数据元素入栈,然后出栈堆栈中的数据元素并在屏幕上显示。
2. 队列类测试和应用问题。
要求:设计一个主函数对循环队列类和链式队列类代码进行测试.测试方法为:依次把数据元素1,2,3,4,5入队,然后出队中的数据元素并在屏幕上显示。
3.设计串采用顺序存储结构,编写函数实现两个串的比较Compare(S, T)。
要求比较结果有大于、等于和小于三种情况。
*4. 设计算法利用栈类实现把十进制整数转换为二至九进制之间的任一进制输出。
*5. 设计串采用静态数组存储结构,编写函数实现串的替换Replace(S, start, T, V),即要求在主串S中,从位置start开始查找是否存在子串T,若主串S中存在子串T,则用子串V替换子串T,且函数返回1;若主串S中不存在子串T,则函数返回0。
并要求设计主函数进行测试。
一个测试例子为:S=”I am a student”,T=”student”,V=”teacher “。
数据结构实验报告(C语言)(强力推荐)
![数据结构实验报告(C语言)(强力推荐)](https://img.taocdn.com/s3/m/0c937808763231126edb1158.png)
数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材:数据结构题集(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;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。
北京信息科技大学-2018年-硕士研究生入学考试大纲-814数据结构C语言考试大纲
![北京信息科技大学-2018年-硕士研究生入学考试大纲-814数据结构C语言考试大纲](https://img.taocdn.com/s3/m/6e688506ff00bed5b9f31dca.png)
2018年研究生入学考试《数据结构》考试大纲【考查目标】1.理解数据结构的基本概念;掌握数据的逻辑结构、存储结构及其差异,以及各种基本操作的实现。
2.掌握基本的数据处理原理和方法的基础上,能够设计简单的算法,并对其进行基本的时间复杂度与空间复杂度的分析。
3.能够选择合适的数据结构和算法进行问题求解,具备采用 C 或C++或JA V A 语言设计与实现算法的能力。
(一) 绪论什么是数据结构;基本概念和术语,数据结构分类;抽象数据类型的表示和实现;逻辑结构、存储结构异同;算法和算法分析包括:算法、算法设计的要求、算法效率的度量、算法的存储空间需求(二)线性表线性表的类型定义,掌握基本概念。
线性表的顺序表示和实现线性表的链式表示和实现线性链表、循环链表、双向链表(三) 栈和队列栈和队列的基本概念和基本操作栈抽象数据类型栈的定义栈的表示和实现栈的应用举例队列抽象数据类型队列的定义链队列——队列的链式表示和实现循环队列——队列的顺序表示和实现顺序表示和实现(四)串串类型的定义串的表示和实现定长顺序存储表示堆分配存储表示串的块链存储表示(五)数组和广义表数组的定义数组的顺序表示和实现矩阵的压缩存储特殊矩阵稀疏矩阵及三元组表示广义表的定义及其存储结构(六)树和二叉树掌握数和二叉树的基本概念和基本操作树的定义和基本术语二叉树二叉树的定义二叉树的性质二叉树的存储结构遍历二叉树树和森林树的存储结构森林与二叉树的转换树和森林的遍历赫夫曼树及其应用(七)图图的定义和术语图的存储结构数组表示法邻接表十字链表邻接多重表图的遍历深度优先搜索广度优先搜索图的连通性问题无向图的连通分量和生成树最小生成树有向无环图及其应用拓扑排序关键路径最短路径(八)查找静态查找表顺序表的查找有序表的查找索引顺序表的查找动态查找表二叉排序表和平衡二叉树B_树和B+树哈希表(九)内部排序了解、掌握各种排序方法的大致思路插入排序直接插入排序希尔排序交换排序冒泡排序快速排序选择排序简单选择排序堆排序归并排序基数排序参考书:[1] 严蔚敏.《数据结构(C语言版)》,清华大学出版社.[2] 严蔚敏.《数据结构题集(C语言版)》,清华大学出版社[3] 王红梅.《数据结构(C++版)》,.清华大学出版社[4] 叶核亚《数据结构(java版)》,电子工业出版社2018年研究生入学考试《C语言》考试大纲C语言程序设计的考试内容一、C语言程序的结构1.程序的构成,main函数和其他函数。
数据结构上机操作实验报告
![数据结构上机操作实验报告](https://img.taocdn.com/s3/m/e73db6838762caaedd33d4be.png)
实验一单链表的基本操作(必做)一、实验目的1.掌握单链表的存储、初始化、插入、删除等操作的程序实现。
2.加深对单链表基本概念,基本理论及相应算法的掌握与理解。
3.了解链表的处理方式,学习体会简单的单链表程序实现相关知识。
二、实验内容1.建立一个链表、设计链表的基本操作实现算法、输出一个链表表,调试并输出结果。
2.编写一个程序实现如下功能:让计算机产生出50个0~9之间的随机数并依次保存到单链表中;输出遍历单链表;从单链表中删除与给定值相等的所有结点;输出遍历单链表;输出单链表长度,调试并输出结果。
三、实验步骤1.定义一个链表结构体。
2.利用插入功能插入一个结点。
3.利用删除功能删除一个结点。
四、程序运行测试1.利用插入功能插入一个结点。
2.利用删除功能删除一个结点。
五、实验报告要求1.绘制链表操作实现的流程图。
2.详细给出程序运行测试结果(包括测试数据和测试结果)。
3.选试验步骤2-3中的任意一个,给出程序的详细注释。
4.参考程序中某一部分功能的改进(选做)5.实验心得与体会6.附录,实验用源程序六、参考源代码#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的单链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个单链表L,数据为整数,数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"在单链表内输入整数:"<<endl;for(int i=0;i<j;i++) p=(LinkList)malloc(sizeof(Lnode)); cin>>p->data;p->next=q->next;q->next=p;q=p; }int PrintLinkList(LinkList &L){//输出单链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"单链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算单链表L的数据元素个数。
北理工数据结构实验二
![北理工数据结构实验二](https://img.taocdn.com/s3/m/87206c12da38376bae1fae1a.png)
《数据结构与算法设计》实验报告——实验二学院:班级:学号:XX:一、实验目的1.通过实验实践、巩固栈的相关操作;2.熟悉VC环境,加强编程、调试的练习;3.用C语言实现栈的抽象数据类型,实现栈的建立、进栈、出栈、取数据等基本操作;4.用C语言实现判断运算符优先级、表达式求值等基本操作;5.理论知识与实际问题相结合,利用上述基本操作实现简单计算器。
二、实验内容1、简单计算器。
请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。
要求:①从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志。
②输入表达式中的数值均为大于等于零的整数。
中间的计算过程如果出现小数也只取整。
例如,输入:4+2*5= 输出:14输入:(4+2)*(2-10)=输出:-48三、程序设计1、概要设计为实现上述程序功能,应用栈存储运算符和操作数,为此需要建立一个抽象数据类型:栈。
(1)、栈的抽象数据类型定义为:ADT Stack{数据对象:D={ai|ai∈ElemSet,i=1,2,3……,n,n≥0}数据关系:R1={ <ai-1,ai>|ai∈D,i=1,2,……,n}基本操作:InitStack(&S)操作结果:创建一个空栈S。
Push(&S, e)初始条件:栈S已存在操作结果:插入运算符e作为新的栈顶元素GetTop(&S)初始条件:栈S已存在且非空操作结果:用e返回寄存运算符栈S的栈顶元素Pop(&S,&e)初始条件:栈S已存在且非空操作结果:删除寄存运算符栈S的栈顶元素Operate(a,theta,b)初始条件:a,b为整数,theta为运算符操作结果:返回a与b运算的结果Precede(d,c)初始条件:d,c为运算符操作结果:若d优先级大于c,返回‘>’;若d优先级小于c,返回‘<’;若d优先级等于c,返回‘=’;EvaluateExpression()初始条件:输入合法的表达式操作结果:返回表达式的值}ADT Stack⑵主程序流程调用EvaluateExpression()函数计算表达式的值,并将结果输出在屏幕上。
数据结构三要素:数据逻辑结构、数据存储结构和数据的运算
![数据结构三要素:数据逻辑结构、数据存储结构和数据的运算](https://img.taocdn.com/s3/m/c43c060353d380eb6294dd88d0d233d4b14e3f36.png)
数据结构三要素:数据逻辑结构、数据存储结构和数据的运算1. 数据的逻辑结构逻辑结构是指数据元素之间的逻辑关系,即从逻辑关系上描述数据。
它与数据的存储⽆关,是独⽴于计算机的。
数据的逻辑结构分为线性结构和⾮线性结构,线性表是典型的线性结构;集合、树和图是典型的⾮线性结构。
数据的逻辑结构分类见图1-1。
集合结构中的数据元素之间除了 “同属于⼀个集合”的关系外,别⽆其他关系。
线性结构结构中的数据元素之间只存在⼀对⼀的关系。
树形结构结构中的数据元素之间存在⼀对多的关系。
图状结构或⽹状结构结构中的数据元素之间存在多对多的关系。
2. 数据的存储结构存储结构是指数据结构在计算机中的表⽰(⼜称映像),也称物理结构。
它包括数据元素的表⽰和关系的表⽰。
数据的存储结构是逻辑结构⽤计算机语⾔的实现,它依赖于计算机语⾔。
数据的存储结构主要有:顺序存储、链式存储、索引存储和散列存储。
1) 顺序存储:把逻辑上相邻的元素存储在物理位置上也相邻的存储单元⾥,元素之间的关系由存储单元的邻接关系来体现。
其优点是可以实现随机存取,每个元素占⽤最少的存储空间;缺点是只能使⽤相邻的⼀整块存储单元,因此可能产⽣较多的外部碎⽚。
2) 链接存储:不要求逻辑上相邻的元素在物理位置上也相邻,借助指⽰元素存储地址的指针表⽰元素之间的逻辑关系。
其优点是不会出现碎⽚现象,充分利⽤所有存储单元;缺点是每个元素因存储指针⽽占⽤额外的存储空间,并且只能实现顺序存取。
3) 索引存储:在存储元素信息的同时,还建⽴附加的索引表。
索引表中的每⼀项称为索引项,索引项的⼀般形式是:(关键字,地址)。
其优点是检索速度快;缺点是增加了附加的索引表,会占⽤较多的存储空间。
另外,在增加和删除数据时要修改索引表,因⽽会花费较多的时间。
4) 散列存储:根据元素的关键字直接计算出该元素的存储地址,⼜称为Hash存储。
其优点是检索、增加和删除结点的操作都很快;缺点是如果散列函数不好可能出现元素存储单元的冲突,⽽解决冲突会增加时间和空间开销。
数据结构实验二
![数据结构实验二](https://img.taocdn.com/s3/m/b9a323bbbdeb19e8b8f67c1cfad6195f312be8e3.png)
数据结构实验二数据结构实验二:队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构,加深对队列和栈实现原理的理解,并熟练掌握队列和栈的基本操作。
二、实验要求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),即常数时间复杂度,具有高效性。
数据结构上机实验二-栈和链队列
![数据结构上机实验二-栈和链队列](https://img.taocdn.com/s3/m/af767e3ba66e58fafab069dc5022aaea998f41e2.png)
数据结构上机实验二-栈和链队列数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求:可单独完成,也可两人一组。
评分标准:1) 只完成第一或第二题,3分;2)完成一和二题,得5分;3)在2)基础上,可选做三)中的题目。
题目:一)堆栈题(顺序栈):创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数,建立相应的堆栈,输入-1时,堆栈结束;(2)在(1)中创建的堆栈中添加一个元素;(3)在(1)中创建的堆栈中删除一个元素;(要求在显示器可见);二)链队列题目:初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列;(2)在初始化好的链队列中放入数,入队列,完成后要求显示;(3)从队列中出队列,要求显示出来的元素和之后的队列;(4)销毁创建的队列,释放内存;三)应用题(1)编制程序,将输入的十进制数据M 转换为八进制数据M8,将其调试通过。
在此基础上修改程序,实现十进制数据M向任意进制(2-9进制)的转换。
(1分)(2)编制程序,从键盘接收一个字符串(长度最长设为100),检测其中的括号(),[],{}匹配情况,若有成对括号则在屏幕输出括号对及其所包含的字符内容。
(2分)(3)假设以I和O分别表示入栈和出栈操作。
栈的初态和终态均为空,入栈和出栈的操作序列可表示为仅由I和O组成的序列,称可以操作的序列为合法序列,否则为非法序列。
编写一个算法,判断所给的序列S1:IOOIIOIOO,S2:IOOIOIIO及S3:IIIOIOIO,S4:IIIOOIOO是否合法。
(1分)(4)二项式(a+b)n展开后,其系数构成杨辉三角形,利用队列写出打印杨辉三角形的前n行的程序。
(1分)1111211331……(5)基于堆栈,编写迷宫求解程序。
数据结构实验报告二(栈、队列与杨辉三角)
![数据结构实验报告二(栈、队列与杨辉三角)](https://img.taocdn.com/s3/m/2d7c75290722192e4536f67f.png)
《数据结构》实验报告项目名称栈、队列与杨辉三角专业班级软件工程工科试验班学号3903120128姓名谢江实验成绩:批阅教师:2012年5月22 日实验1《单链表的建立与约瑟夫问题》实验学时:实验地点:寝室与实验室实验日期:2012年5月22日1.需求分析实验2 主要是关于栈。
队列的建立以及杨辉三角问题的解决(队列运用)2.概要设计以及详细设计(1)栈class Stack{public:Stack();bool empty();//判断栈是否为空T peek();//显示栈顶元素void push(T value);//入栈T pop();//出栈int getSize();//当前栈中元素的数量private:T *elements;//数组指针int size;//栈中的元素数量int capacity;//栈的容量void ensureCapacity();//确认栈的容量是否大于元素数量};(2)队列class Queue{public:Queue();void enQueue(T element);//元素入队T deQueue();//元素出对,如果没有元素,抛出异常int getSize();//获取队列大小private:LinkedList<T> list;//定义表};3.调试分析内容包括:调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析;算法的时空分析(包括基本操作和其他算法的时间复杂度和空间复杂度的分析)和改进设想;经验和体会等。
个人标记:能建立顺序栈,以及链表顺序队列,对于比较复杂的链栈、循环队列等比较不熟悉,杨辉三角问题存在问题此次报告暂时不交,还有就是抛出异常的问题,例如:T deQueue()throw (runtime_error);//元素出对,如果没有元素,抛出异常会提示警告:C++ exception specification ignored except to indicate a function is not_declspec(nothrow)于是尽可能用if(…)throw runtime_error,就不报错了4.附录(1)栈Stack.h*****************************//采用数组的方式进行栈的操作#ifndef STACK_H#define STACK_Htemplate<typename T>class Stack{public:Stack();bool empty();//判断栈是否为空T peek();//显示栈顶元素void push(T value);//入栈T pop();//出栈int getSize();//当前栈中元素的数量private:T *elements;//数组指针int size;//栈中的元素数量int capacity;//栈的容量void ensureCapacity();//确认栈的容量是否大于元素数量};template<typename T>Stack<T>::Stack(){capacity = 10;//初始栈的大小size = 0;//初始元素的数量elements = new T[capacity];//建立指针}template<typename T>bool Stack<T>::empty(){if(size == 0)return true;elsereturn false;}template<typename T>//只显示栈顶元素并不出栈T Stack<T>::peek(){return elements[size - 1];}template<typename T>void Stack<T>::ensureCapacity(){if(size >= capacity)//如果满足进行指针的更换{T *old = elements;capacity = size + 1;elements = new T[capacity];for(int i = 0; i < size; i++)elements[i] = old[i];delete old;}}template<typename T>void Stack<T>::push(T value){ensureCapacity();//入栈前进行栈是否溢出的判断elements[size++] = value;}template<typename T>T Stack<T>::pop(){return elements[--size];}template<typename T>int Stack<T>::getSize(){return size;}#endif*************************************TestStack.cpp*************************************#include<iostream>#include"Stack.h"using namespace std;int main(){Stack<int> intS;cout << "before push size of intStack is: " << intS.getSize() << endl;//统计入栈前栈的大小for(int i = 0; i < 10; i++){int num;cout << "enter num: ";cin >> num;intS.push(num);}cout << "now size of intStack is: " << intS.getSize() << endl;//统计入栈后栈的大小while(!intS.empty()){cout << intS.pop() << " out " << endl;}cout << "after pop size of intStack is: " << intS.getSize() << endl;//出站后栈的大小system("pause");return 0;}##################################################(2)队列LinkedList.h******************************************#ifndef LINKEDLIST_H#define LINKEDLIST_H#include<stdexcept>using namespace std;template<typename T>class Queue;//前视定义,否则无法友元template<typename T>class Node{public :T element;//节点数据域Node<T> *next;//指向下指针Node(){next = NULL;}Node(T element){this -> element = element;next = NULL;}};template<typename T>class LinkedList{public:LinkedList();T removeFirst();//移除并返回表头元素void addLast(T element);//尾端插入新元素int getSize();//获取表的大小private:Node<T> *head, *tail;//定义头节点、尾节点int size;};template<typename T>LinkedList<T>::LinkedList()//初始化链表NULL{head = tail = NULL;size = 0;}template<typename T>void LinkedList<T>::addLast(T element){if(tail == NULL){head = tail = new Node<T>(element);}else{tail ->next = new Node<T>(element);tail = tail ->next;}size++;//作添加工作,size++}template<typename T>T LinkedList<T>::removeFirst(){if(size == 0)throw runtime_error("No elements");//抛出异常情况else{//删除并返回头节点元素,把下一节点作为新的头节点Node<T> *temp = head;head = head ->next;if(head == NULL)tail = NULL;size--;//作删除工作,size--T element = temp ->element;delete temp;return element;}}template<typename T>int LinkedList<T>::getSize()//返回size{return size;}#endif****************************************Queue.h***********************************#ifndef QUEUE_H#define QUEUE_H#include"LinkedList.h"#include<stdexcept>using namespace std;template<typename T>class Queue{public:Queue();void enQueue(T element);//元素入队T deQueue();//元素出对,如果没有元素,抛出异常int getSize();//获取队列大小private:LinkedList<T> list;//定义表};template<typename T>Queue<T>::Queue(){}//空的构造函数template<typename T>void Queue<T>::enQueue(T element){list.addLast(element);//入队(后插)}template<typename T>T Queue<T>::deQueue(){return list.removeFirst();//出对(前删)}template<typename T>int Queue<T>::getSize(){return list.getSize();}#endif******************************************* TestQueue.cpp*******************************************#include<iostream>#include<stdexcept>#include"Queue.h"using namespace std;int main(){Queue<int> q;cout << "before enQueue size is: " << q.getSize() << endl;for(int i = 0; i < 10; i++){q.enQueue(i);cout << i << " enter queue" << endl;}cout << "after enQueue size si: " << q.getSize() << endl;while(q.getSize()!=0){cout << q.deQueue() << "out queue" << endl;}cout << "after deQueue size is: " << q.getSize() << endl;system("pause");return 0;}。
《数据结构》实验指导及实验报告栈和队列
![《数据结构》实验指导及实验报告栈和队列](https://img.taocdn.com/s3/m/31a660eb0342a8956bec0975f46527d3240ca6cf.png)
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的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题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。
北京理工大学数据结构实验报告二__堆栈和队列
![北京理工大学数据结构实验报告二__堆栈和队列](https://img.taocdn.com/s3/m/0b7c1b47f7ec4afe04a1dfc1.png)
数据结构实验报告(二)实验二堆栈和队列一、实验目的和要求:1、掌握堆栈和队列的基本概念;2、掌握堆栈和队列的基本操作。
二、实验原理:1、堆栈的定义:堆栈是一种只允许在表的一端进行插入和删除运算的特殊的线性表。
允许进行插入和删除运算的一端称为栈顶,另一端称为栈底,当链表中没有元素时,称为空栈。
2、堆栈的插入运算称为入栈或者进栈,删除运算称为出栈或者退栈,栈顶的当前位置是动态的,标识栈顶当前位置的指针称为栈顶指针。
每次进栈的数据元素都放在原当前栈顶元素之前成为新的栈顶元素,每次退栈的数据元素都是原当前栈顶元素,最后进入堆栈的数据元素总是最先退出堆栈。
3、堆栈的存储结构:(1)顺序存储结构:栈的顺序存储结构称为顺序栈。
顺序栈的本质是顺序表的简化。
(2)链式存储结构:栈的链式存储结构称为链栈,通常用单链表示。
链栈的插入和删除操作只需处理栈顶的情况。
4、队列的定义:队列是允许在表的一端进行插入,而在表的另一端进行删除的特殊线性表。
允许进行插入的一端称为队尾,允许进行删除的一端称为队头。
队列的插入运算称为进队或者入队,删除运算称为出队或者离队,因此队列又称为先进先出表。
5、队列的存储结构队列的存储结构同线性表一样,可以分为顺序结构和链式结构。
(1)顺序存储结构:用顺序存储结构存储队列称为顺序队列。
顺序队列会出现假溢出问题,解决办法是用首尾相接的书顺序存储结构,称为循环队列。
在队列中,只要涉及队头或者队尾指针的修改都要对其求模。
(2)链式存储结构:用链式存储结构存储的队列称为链队列。
链队列的基本操作的实现基本上也是单链表操作的简化。
通常附设头结点,并设置队头指针指向头结点,队尾指针指向终端结点。
插入数据时只考虑在链队列的尾部进行,删除数据时只考虑在链队列的头部进行。
三、实验内容:1、试编写一个算法,建立一个学生成绩栈,要求从键盘上输入N个整数,按照下列要求分别进入不同的栈。
(1)若输入的整数X小于60,则进入第一个栈;(2)若输入的整数x大于等于60并小于100,则进入第二个栈;(3)若输入的整数x大于100,则进入第三个栈;(4)分别输出每个栈的内容。
北京理工大学数据结构实验报告 简易计算器(二叉树)
![北京理工大学数据结构实验报告 简易计算器(二叉树)](https://img.taocdn.com/s3/m/0bdd4dd189eb172dec63b70b.png)
数据结构实验报告三——简易计算器(二叉树)姓名:任子龙学号:1120140167 班级:05111451一、需求分析(1)问题描述由键盘输入一算术表达式,以中缀形式输入,试编写程序将中缀表达式转换成一棵二叉表达式树,通过对该二叉树的后序遍历求出计算表达式的值。
(2)基本要求a.要求对输入的表达式能判断出是否合法,不合法要有错误提示信息。
b.将中缀表达式转换成二叉表达式树。
c.后序遍历求出表达式的值。
(3)数据结构与算法分析一棵表达式树,它的树叶是操作数,如常量或变量名字,而其他的结点为操作符。
a.建立表达式树。
二叉树的存储可以用顺序存储也可用链式存储。
当要创建二叉树时,先从表达式尾部向前搜索,找到第一个优先级最低的运算符,建立以这个运算符为数据元素的根结点。
注意到表达式中此运算符的左边部分对应的二叉绔为根结点的左子树,右边部分对应的是二叉绔为根结点的右子树,根据地这一点,可用递归调用自己来完成对左右子树的构造。
b.求表达式的值。
求值时同样可以采用递归的思想,对表达式进行后序遍历。
先递归调用自己计算左子树所代表的表达式的值,再递归调用自己计算右子树代表的表达式的值,最后读取根结点中的运算符,以刚才得到的左右子树的结果作为操作数加以计算,得到最终结果。
(4)测试a.加减运算输入:6+9-5 输出:10b.乘除运算输入:5.6*2.7/2 输出:7.56c.四则混合运算输入:(2+3)*8-3/2 输出:23.5d.非法输入输入:(5+6(*5 输出:括号不匹配!1.2问题分析与之前利用栈实现计算器功能不同,本实验采取的方法是:将中缀表达式转换成一棵二叉表达式树,通过对该树的后序遍历求出计算表达式的值。
所以,实验的重点是如何“将中缀表达式转换成一棵二叉表达式树”;如上图所示,该二叉表达式树表示的是计算式(5+2)*3。
可以看出,操作数均为叶子结点,其它结点为操作符;构建二叉树的整体思路是:(1)将中缀表达式转化为后缀表达式;(2)利用(1)中的后缀表达式,在此基础上构建二叉表达式树。
数据结构和算法课程设计题目
![数据结构和算法课程设计题目](https://img.taocdn.com/s3/m/7a09f4996294dd88d1d26b49.png)
北方民族大学课程设计课程名称:数据结构与算法院(部)名称:信息与计算科学学院组长姓名学号同组人员姓名指导教师姓名:纪峰设计时间:2010.6.7----2009.6.27一、《数据结构与算法》课程设计参考题目(一)参考题目一(每位同学选作一个,同组人员不得重复)1、编写函数实现顺序表的建立、查找、插入、删除运算。
2、编写函数分别实现单链表的建立、查找、插入、删除、逆置算法。
3、编写函数实现双向链表的建立、插入、删除算法。
4、编写函数实现顺序栈的进栈、退栈、取栈顶的算法。
5、编写函数实现链栈的进栈、退栈、取栈顶的算法。
6、编写函数实现双向顺序栈的判空、进栈、出栈算法。
7、编写函数实现循环队列的判队空、取队头元素、入队、出队算法。
8、编写函数实现链环队列的判队空、取队头节点、入队、出队算法。
9、编写函数实现串的,求串长、连接、求字串、插入、删除等运算。
10、分别实现顺序串和链串的模式匹配运算。
11、实现二叉树的建立,前序递归遍历和非递归遍历算法。
12、实现二叉树的建立,中序递归遍历和非递归遍历算法。
13、实现二叉树的建立,后序递归遍历和非递归遍历算法。
14、实现二叉树的中序线索化,查找*p结点中序下的前驱和后继结点。
15、分别以临接表和邻接矩阵作为存储就够实现图的深度优先搜索和广度优先搜索算法。
16、利用线性探测处理冲突的方法实现散列表的查找和插入算法。
(二)参考题目二(每三人一组,任选三个题目完成)1.运动会分数统计(限1人完成)任务:参加运动会有n个学校,学校编号为1……n。
比赛分成m个男子项目,和w个女子项目。
项目编号为男子1……m,女子m+1……m+w。
不同的项目取前五名或前三名积分;取前五名的积分分别为:7、5、3、2、1,前三名的积分分别为:5、3、2;哪些取前五名或前三名由学生自己设定。
(m<=20,n<=20)功能要求:1)可以输入各个项目的前三名或前五名的成绩;2)能统计各学校总分,3)可以按学校编号或名称、学校总分、男女团体总分排序输出;4)可以按学校编号查询学校某个项目的情况;可以按项目编号查询取得前三或前五名的学校。
数据结构实验题目
![数据结构实验题目](https://img.taocdn.com/s3/m/19be8e5532687e21af45b307e87101f69f31fb55.png)
数据结构实验题⽬实验⼀线性表1 实验⽬的通过选择下⾯四个题⽬之⼀进⾏实现,掌握如下内容:熟悉C++语⾔的基本编程⽅法,掌握集成编译环境的调试⽅法学习指针、模板类、异常处理的使⽤掌握线性表的操作的实现⽅法学习使⽤线性表解决实际问题的能⼒2 实验内容2.1题⽬1根据线性表的抽象数据类型的定义,选择下⾯任⼀种链式结构实现线性表,并完成线性表的基本功能。
线性表存储结构(五选⼀):1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能:1、构造:使⽤头插法、尾插法两种⽅法2、插⼊:要求建⽴的链表按照关键字从⼩到⼤有序3、删除4、查找5、获取链表长度6、销毁7、其他:可⾃⾏定义编写测试main()函数测试线性表的正确性。
2.2题⽬2利⽤线性表实现⼀个通讯录管理,通信录的数据格式如下:struct DataType{int ID; //编号char name[10]; //姓名char ch; //性别char phone[13]; //电话char addr[31]; //地址};要求:实现通讯录的建⽴、增加、删除、修改、查询等功能能够实现简单的菜单交互,即可以根据⽤户输⼊的命令,选择不同的操作。
能够保存每次更新的数据(选作)能够进⾏通讯录分类,⽐如班级类、好友类、⿊名单等等(选作)编写测试main()函数测试线性表的正确性2.3题⽬3利⽤线性表实现⼀个⼀元多项式Polynomialf(x) = a+ a1x + a2x2 + a3x3+ … + a n x n提⽰:Polynomial的结点结构如下:struct term{float coef; //系数int expn; //指数};可以使⽤链表实现,也可以使⽤顺序表实现。
要求:能够实现⼀元多项式的输⼊和输出能够进⾏⼀元多项式相加能够进⾏⼀元多项式相减能够计算⼀元多项式在x处的值能够计算⼀元多项式的导数(选作)能够进⾏⼀元多项式相乘(选作)编写测试main()函数测试线性表的正确性2.4题⽬4利⽤循环链表实现约瑟夫问题的求解。
数据结构试验:栈和队列实验——表达式求值
![数据结构试验:栈和队列实验——表达式求值](https://img.taocdn.com/s3/m/48b48f24b4daa58da0114aa6.png)
实验报告课程名称数据结构实验项目实验二--栈和队列实验系别___ _计算机学院 _ ______专业___ _计算机科学与技术___班级/学号__学生姓名 ____________实验日期成绩_______________________指导教师实验题目:实验二-----栈和队列实验一、实验目的1)掌握栈的顺序存储结构及队列的链式存储结构;2)验证栈的顺序存储结构的操作的实现;3)验证队列的链式存储结构的操作的实现;4)理解算法与程序的关系,能够将算法转换为对应程序。
二、实验内容1)建立一个顺序存储的空栈,并以此分别实现入栈、出栈、取栈顶元素;2)建立一个链式结构的空队列,并以此分别实现入队、出队、取队头等基本操作;3)尝试利用栈和队列的算法解决一些实际的应用问题。
设计与编码1)实验题目主要需求说明2)设计型题目:表达式求值(要求利用栈结构和运算符优先约定表,输入一个表达式,并计算求值)3)结合题目,说明利用栈或队列解决问题的基本算法描述4)程序源码#include<iostream>using namespace std;const int InitSize=100;const int IncreastSize=10;template<class datatype>class SqStack {private:datatype *base;datatype *top;int stacksize;public:SqStack();void DestroyStack();void ClearStack();int StackLength();bool IsEmpty();bool GetTop(datatype &e);bool Pop(datatype &e);bool Push(datatype e);};template<class datatype>SqStack<datatype>::SqStack(){base=new datatype[InitSize];if(!base)exit(1);top=base;stacksize=InitSize;}template<class datatype>void SqStack<datatype>::DestroyStack() {delete[] base;base=top=NULL;stacksize=0;}template<class datatype>void SqStack<datatype>::ClearStack() {top=base;}template<class datatype>int SqStack<datatype>::StackLength() {return top-base;}template<class datatype>bool SqStack<datatype>::IsEmpty() {if(top==base)return fasle;else return true;}template<class datatype>bool SqStack<datatype>::GetTop(datatype &e){if(top==base)return false;e=*(top-1);return true;}template<class datatype>bool SqStack<datatype>::Pop(datatype &e){if(top==base)return false;e=*(top-1);top--;return true;}template<class datatype>bool SqStack<datatype>::Push(datatype e){if(top-base>=stacksize){base=(datatype *)realloc( base , (stacksize+IncreastSize)*sizeof(int) ); if(!base)exit(1);top=base+stacksize;stacksize+=IncreastSize;}*(top)=e;top++;return true;}int com(char m,char t){if(t=='(') return -1;else if(t==')'){if(m=='+'||m=='-'||m=='*'||m=='/') return 1; else if(m=='(') return 0;else return -2;}else if(t=='*'||t=='/'){if(m=='+'||m=='-'||m=='#'||m=='(') return -1; else return 1;}else if(t=='+'||t=='-'){if(m=='#'||m=='(') return -1;else return 1;}else{if(m=='#')return 0;else if(m=='+'||m=='-'||m=='*'||m=='/') return 1; else return -2;}}void main(){SqStack <char> op;SqStack <double> re;char t,m;double result,flag=1;op.Push('#');t=getchar();while(true){if(t>='0'&&t<='9'){double s=0;s=s*10+t-'0';t=getchar();while(t>='0'&&t<='9' ){s=s*10+t-'0';t=getchar();}re.Push(s);}else if(t=='+'||t=='-'||t=='*'||t=='/'||t=='('||t==')'||t=='\n') { op.GetTop(m);while(com(m,t)==1 ){double x1,x2;op.Pop(m);if(re.Pop(x2)&&re.Pop(x1)){if(m=='+') re.Push(x1+x2);else if(m=='-') re.Push(x1-x2);else if(m=='*') re.Push(x1*x2);else if(m=='/') {if(x2!=0)re.Push(x1/x2); else flag=0;} }else flag=0;op.GetTop(m);}if(com(m,t)==-1)op.Push(t);else if(com(m,t)==0)op.Pop(m);else flag=0;if(!op.GetTop(m)) break;t=getchar();}else t=getchar();}if(re.GetTop(result)&&flag)cout<<result<<endl;else cout<<"Input error!\n";}5)运行结果三、总结与心得。
实验报告一--链接栈与顺序队列的基本运算
![实验报告一--链接栈与顺序队列的基本运算](https://img.taocdn.com/s3/m/3b20c5d5ad51f01dc281f156.png)
课程实验报告题目链接栈与顺序队列的基本运算班级2010信息与计算科学班姓名笑嘻嘻小学号笑嘻嘻完成日期笑嘻嘻小㈠实验要求:编程实现链接栈与顺序队列的基本运算。
链接栈:插入元素,删除栈顶元素,读出栈顶元素,判断栈是否为空。
顺序队列:队列的插入,队列的删除,读队头元素,判断队列是否为空。
实验目的:熟练掌握链接栈,顺序队列的基本运算。
链接栈的结点结构与单链表的结点结构完全相同,即,将链接栈组织成单链表形式。
注意,链接栈中指针的方向是从栈顶指向栈底。
顺序队列是用顺序存储方法存储的队列。
分配一片连续的存储空间,存放队列中的表目,并用两个变量分别指向队头和队尾。
㈡I.链接栈的基本运算I.1实验代码:#include<stdio.h>#include<malloc.h>#define LEN sizeof(struct node)#define NULL 0struct node{int info;struct node*link;};struct linklist{struct node*T;};//*主函数*//void main(){int x;struct linklist L;L.T=(struct node*)malloc(LEN);L.T=NULL;struct linklist push(struct linklist L,int x);struct linklist pop(struct linklist L);int top(struct linklist L);int sempty(struct linklist L); /*函数声明*/for(x=10;x<=50;x=x+10)L=push(L,x); /*向栈顶插入五个元素10,20,30,40,50*/ printf("向栈顶插入五个元素后,");printf("栈顶元素为%d。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
SNode_N *p; p=(SNode_N *)malloc(sizeof(SNode_N)); if(!p) exit(0); p->data=e; p->next=S->top; S->top=p; S->length++; return 1; }
if(!S.top)return 0; else {
printf("返回栈顶元素%5d\n",S.top->data); } return 0; }//返回栈顶元素
int PrintStack(SqStack &S) {
Stack p; printf("\n 链式队列中的元素"); p=S.top; if(S.top!=NULL) {
int InitStack(SqStack & S) {
S.top=NULL; S.length=0; return 0; }//初始化链式栈
int Push(SqStack &S,int e) {
Stack p; p=(Stack)malloc(sizeof(SNode)); if(!p)exit(0); p->data=e; p->next=S.top; S.top=p; S.length++; return 0; }//插入元素 e
float s; switch(c){
case '+':s=a+b; break; case '-':s=a-b; break; case '*':s=a*b; break; case '/':
if(b!=0) s=a/b; else
printf("Input error!");break; } return s; }
typedef struct SNode_T {
char data; struct SNode_T *next; }SNode_T;
typedef struct SNode_N{ float data; struct SNode_N *next;
}SNode_N;
typedef struct SqStack_T{ int length; SNode_T *top;
void main() {
SqStack S; int e,m; InitStack(S);
for(;;) {
printf("1.插入元素;2.删除元素;3.栈顶元素;4.结束运行 \n\n");
printf("选择: "); scanf("%d",&m); printf("\n"); switch(m) { case 1 : printf(" 插 入 元 素 : ");scanf("%d",&e);Push(S,e);PrintStack(S);printf("\n");break;
}SqStack_T;
typedef struct SqStack_N {
int length; SNode_N *top; }SqStack_N;
void InitStack_T(SqStack_T *S)
{ S->top=NULL; S->length=0;
}
void InitStack_N(SqStack_N *S) {
int Put(SqQueue &Q,int n) {
for(int i=0;i<n;i++) {
scanf("%d",&Q.base[i]); EnQueue(Q,Q.base[i]); } return OK; }
void Out(SqQueue &Q,int n) { printf("该队列为:"); for(int i=0;i<n;i++) printf("%d ",Q.base[i]); }
char Pop_T(SqStack_T *S) {
char e; SNode_T *p;
if(S->top==NULL) return -1; p=S->top; e=p->data; S->top=p->next; S->length--; free(p); return e; }
float Pop_N(SqStack_N *S) {
Status DeQueue (SqQueue &Q, QElemType e) {//若队列不空,则删除 Q 的队头元素,用 e 返回其值,并返回 OK;否 则返回 ERROR if(Q.front == Q.rear) return ERROR; e=Q.base[Q.front];
Q.front=(Q.front + 1) % MAXQSIZE; return OK; }
2.循环队列:
#include<stdio.h> #include<stdlib.h>
#define MAXQSIZE 100 //最大队列长度 #define OK 1 #define OVERFLOW -2 #define ERROR 0
typedef int QElemType;
typedef int Status;
实验报告
课程名称 实验项目 实验仪器
数据结构 链栈、循环队列和计算器的操作
计算机
系别 专业 班级/学号 学生姓名 实验日期 成绩 指导教师
计算机学院学院
一 、实验目的 (1) 熟悉链栈的操作方法 (2) 熟悉循环队列的操作方法 (3) 利用栈的特点来编写简易计算器 (4) 了解各自的优缺点。
二、 实验内容 (1) 用链栈实现数据的增、删、查功能
while(p!=NULL) {
printf("%5d",p->data); p=p->next; } } else printf("队列为空\n"); printf("\n"); return 0; }//遍历链式栈
int ClearStack(SqStack & S) {
S.top=NULL; printf("已置空链式栈"); printf("\n"); return 0; }//置空链式栈
float e; SNode_N *p; if(S->top==NULL) return -1; p=S->top; e=p->data; S->top=p->next; S->length--; free(p); return e; }
float Operate(float a,char c,float b) {
int QueueLength (SqQueue &Q) { int x=0; x=(Q.rear-Q.front+MAXQSIZE) % MAXQSIZE; printf("该队列长为:%d",x); return 0; }
Status EnQueue (SqQueue &Q, QElemType e) {//插入元素 e 为 Q 的新的队尾元素 int y=0; if((Q.rear+1) % MAXQSIZE == Q.front ) return ERROR;//队列满 if(e==0) {
int main() { int i=0,n=0,a=0,e=0; SqQueue Q; InitQueue(Q); printf("请指定该队列有多少个元素:"); scanf("%d",&n); printf("请输入这%d 个元素:",n); Put(Q,n); Out(Q,n); for(;;)
int GetTop_N(SqStack_N *S) {
int e; SNode_N *p; if(S->top==NULL) return -1;
p=S->top; e=p->data; return e; }
char GetTop_T(SqStack_T *S) {
char e; SNode_T *p; if(S->top==NULL) return -1; p=S->top; e=p->data; return e; }
S->top=0; S->length=0; }
int Push_T(SqStack_T *S,char e) {
SNode_T *p; p=(SNode_T *)malloc(sizeof(SNode_T)); if(!p) exit(0); p->data=e; p->next=S->top; S->top=p; S->length++; return 1; }
case 3 : system("cls");break;
case 4 : QueueLength(Q);break;
case 5 : return 0;
default : printf("输入指令有误!");break; }
}
return 0; }
3.计算器:
#include<stdio.h> #include<stdlib.h>
int Suffix(char c,char s[]) {
int i=0; while(s[i]!=c)