数据结构实验二(栈和队列)
数据结构栈和队列
实验二栈和队列一、实验目的1、掌握栈的特点(先进后出FILO)及基本操作，如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。
2、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，队列顺序存储结构、链式存储结构和循环队列的实现，以便在实际问题背景下灵活应用。
二、实验内容1、顺序栈的实现和运算；2、循环队列的实现和运算；3、栈的运用—十进制转八进制运算。
三、实验要求1、学生用C++/C完成算法设计和程序设计并上机调试通过；2、撰写实验报告，提供实验测试数据和实验结果；3、分析算法，要求给出具体的算法分析结果，包括时间复杂度和空间复杂度，并简要给出算法设计小结和心得。
四、实验准备1、掌握栈和队列这两种抽象数据类型的特点，并能在相应的应用任务中正确选用它们；2、熟练掌握顺序栈和循环队列的基本操作实现算法，特别应注意栈满和栈空的条件以及它们的描述方法，循环队列中队满和队空的描述方法。
3、在学习顺序栈的基本操作实现算法时，应注意：在书上给出的结构定义是采用了一种动态管理方式（不够时，可以再分配），但在C 语言中，用数组来存储顺序栈，是静态分配，即不能随机分配空间，这点易引起大家的误解。
五、实验步骤1、编程实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：(1)初始化顺序栈；(2)给定一个元素，将此元素压入此栈中；(3)将栈顶一个元素弹出此栈。
2、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能：(1)初始化循环队列；(2)给定一个元素，将此元素插入此队列中；(3)将队头一个元素出队。
3、栈的运用实例十进制转八进制。
六、实验参考代码1、顺序栈的实现和运算；#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;//----- 栈的顺序存储表示-----#define STACK_INIT_SIZE 100 // 存储空间的初始分配量#define STACKINCREMENT 10 // 存储空间的分配增量typedef struct {ElemType *base;ElemType *top;int stacksize;} SqStack;// 构造一个空栈SStatus InitStack(SqStack &S){S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}// 判栈S是否为空栈Status StackEmpty(SqStack S){if (S.top==S.base) return OK;else return ERROR;}//入栈函数Status Push (SqStack &S, ElemType e) {if(S.top - S.base >= S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(ElemType)); if(!S.base) exit (OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}* S.top++ = e;return OK;}//出栈函数Status Pop (SqStack &S, ElemType &e) {if(S.top == S.base) return ERROR;e = * --S.top;return OK;}//输出顺序栈函数void OutStack(SqStack S){ int *p;if(S.top == S.base){printf("这是一个空栈！");}elsefor(p= S.top-1; p>= S.base;p--)printf("%6d", *p);printf("\n");}//主函数void main(){ SqStack s;int cord; ElemType a;printf("第一次使用必须初始化！\n");do{printf("\n 主菜单\n");printf(" 1 初始化顺序栈");printf(" 2 插入一个元素");printf(" 3 删除栈顶元素");printf(" 4 结束程序运行");printf("\n------------------------------------------------------------------------------\n"); printf("请输入您的选择( 1, 2, 3, 4)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:InitStack(s);OutStack(s);break;case 2:printf("请输入要插入的数据元素：a=");scanf("%d",&a);Push(s,a);printf("%d 进栈之后的栈：",a);OutStack(s);break;case 3:Pop(s,a);printf("栈顶元素%d 出栈之后的栈：",a);OutStack(s);break;case 4:exit(0);}}while (cord<=4);}2、循环队列的实现和运算；#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int QElemType;typedef int Status;//----- 队列的顺序存储表示-----#define MAXQSIZE 100 // 存储空间的初始分配量typedef struct {QElemType *base;int front;int rear;} SqQueue;// 构造一个空队列QStatus InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OVERFLOW);Q.front=Q.rear=0;return OK;}//判队列是否为空Status QueueEmpty (SqQueue Q) {if(Q.rear==Q.front) return OK;else return ERROR ;}//入队函数Status EnQueue (SqQueue &Q, QElemType e) {if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}//出队函数Status DeQueue (SqQueue &Q, QElemType &e) {if(Q.rear==Q.front) return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}//输出循环队列函数void OutQueue(SqQueue Q)if(Q.front == Q.rear){printf("这是一个空队列！");}else{n= (Q.rear- Q.front+ MAXQSIZE) % MAXQSIZE;i= 1;while ( i<= n){printf("%6d", Q.base[(Q.front+i-1)% MAXQSIZE] );i++;}printf("\n");}}//主函数void main(){ SqQueue q;int cord; QElemType a;printf("第一次使用必须初始化！\n");do{printf("\n 主菜单\n");printf(" 1 初始化循环队列");printf(" 2 进队一个元素");printf(" 3 出队一个元素");printf(" 4 结束程序运行");printf("\n------------------------------------------------------------------------------\n"); printf("请输入您的选择( 1, 2, 3, 4)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:InitQueue(q); //调用初始化算法;OutQueue(q);break;case 2:printf("请输入要插入的数据元素：a=");scanf("%d",&a);EnQueue (q, a); //调用进队算法;printf("%d 进队之后的队列：",a);OutQueue(q);break;case 3:DeQueue (q, a); //调用出队算法;printf("队头元素%d 出队之后的队列：",a);OutQueue(q);break;exit(0);}}while (cord<=4);}3、栈的应用—十进制转八进制#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct {ElemType *base;ElemType *top;int stacksize;} SqStack;// 构造一个空栈SStatus InitStack(SqStack &S){S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}// 判栈S是否为空栈Status StackEmpty(SqStack S){if (S.top==S.base) return OK;else return ERROR;}//入栈函数Status Push (SqStack &S, ElemType e) {if(S.top - S.base >= S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(ElemType)); if(!S.base) exit (OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}* S.top++ = e;return OK;}//出栈函数Status Pop (SqStack &S, ElemType &e) {if(S.top == S.base) return ERROR;e = * --S.top;return OK;}//十进制转八进制函数void conversion(){ SqStack S;int n,e;InitStack(S);printf("请输入一个十进制数：");scanf("%d",&n);while(n){Push(S,n%8);n=n/8;}printf("转换之后的八进制数为：");while(!StackEmpty(S)){Pop(S, e);printf("%d",e);}printf("\n");}void main(){conversion();}（注：文档可能无法思考全面，请浏览后下载，供参考。
数据结构栈和队列实验报告
数据结构栈和队列实验报告实验报告：数据结构栈和队列一、实验目的1.了解栈和队列的基本概念和特点；2.掌握栈和队列的基本操作；3.掌握使用栈和队列解决实际问题的方法。
二、实验内容1.栈的基本操作实现；2.队列的基本操作实现；3.使用栈和队列解决实际问题。
三、实验原理1.栈的定义和特点：栈是一种具有后进先出(LIFO)特性的线性数据结构，不同于线性表，栈只能在表尾进行插入和删除操作，称为入栈和出栈操作。
2.队列的定义和特点：队列是一种具有先进先出(FIFO)特性的线性数据结构，不同于线性表，队列在表头删除元素，在表尾插入元素，称为出队和入队操作。
3.栈的基本操作：a.初始化：建立一个空栈；b.入栈：将元素插入栈的表尾；c.出栈：删除栈表尾的元素，并返回该元素；d.取栈顶元素：返回栈表尾的元素，不删除。
4.队列的基本操作：a.初始化：建立一个空队列；b.入队：将元素插入队列的表尾；c.出队：删除队列表头的元素，并返回该元素；d.取队头元素：返回队列表头的元素，不删除。
四、实验步骤1.栈的实现：a.使用数组定义栈，设置栈的大小和栈顶指针；b.实现栈的初始化、入栈、出栈和取栈顶元素等操作。
2.队列的实现：a.使用数组定义队列，设置队列的大小、队头和队尾指针；b.实现队列的初始化、入队、出队和取队头元素等操作。
3.使用栈解决实际问题：a.以括号匹配问题为例，判断一个表达式中的括号是否匹配；b.使用栈来实现括号匹配，遍历表达式中的每个字符，遇到左括号入栈，遇到右括号时将栈顶元素出栈，并判断左右括号是否匹配。
4.使用队列解决实际问题：a.以模拟银行排队问题为例，实现一个简单的银行排队系统；b.使用队列来模拟银行排队过程，顾客到达银行时入队，处理完业务后出队，每个顾客的业务处理时间可以随机确定。
五、实验结果与分析1.栈和队列的基本操作实现：a.栈和队列的初始化、入栈/队、出栈/队以及取栈顶/队头元素等操作均能正常运行；b.栈和队列的时间复杂度均为O(1)，操作效率很高。
实验二 栈和队列
实验二栈和队列本文档旨在介绍实验二的目的和背景，以及本实验的重要性。
实验二主要涉及栈和队列的相关概念和操作。
栈和队列是常用的数据结构，它们在计算机科学和软件开发中起着重要的作用。
栈是一种先进后出（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.判断栈空。
数据结构实验二
数据结构实验二数据结构实验二：队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构，加深对队列和栈实现原理的理解，并熟练掌握队列和栈的基本操作。
二、实验要求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.熟练并掌握栈在顺序存储结构和链表存储结构下的基本运算；3.熟悉队列这种特殊线性结构的特性；3.熟练掌握队列在链表存储结构下的基本运算。
实验原理：堆栈顺序存储结构下的基本算法；堆栈链式存储结构下的基本算法；队列顺序存储结构下的基本算法；队列链式存储结构下的基本算法；实验容：3-18 链式堆栈设计。
要求（1）用链式堆栈设计实现堆栈，堆栈的操作集合要求包括：初始化StackInitiate（S）,非空否StackNotEmpty(S)，入栈StackiPush(S,x),出栈StackPop（S,d）,取栈顶数据元素StackTop(S,d); （2）设计一个主函数对链式堆栈进行测试。
测试方法为：依次把数据元素1，2，3，4，5入栈，然后出栈并在屏幕上显示出栈的数据元素；（3）定义数据元素的数据类型为如下形式的结构体，Typedef struct{char taskName[10];int taskNo;}DataType;首先设计一个包含5个数据元素的测试数据，然后设计一个主函数对链式堆栈进行测试，测试方法为：依次吧5个数据元素入栈，然后出栈并在屏幕上显示出栈的数据元素。
3-19 对顺序循环队列，常规的设计方法是使用対尾指针和对头指针，对尾指针用于指示当前的対尾位置下标，对头指针用于指示当前的対头位置下标。
现要求：（1）设计一个使用对头指针和计数器的顺序循环队列抽象数据类型，其中操作包括：初始化，入队列，出队列，取对头元素和判断队列是否为空；（2）编写一个主函数进行测试。
实验结果：3-18typedef struct snode{DataType data;struct snode *next;} LSNode;/*初始化操作：*/void StackInitiate(LSNode **head)/*初始化带头结点链式堆栈*/{if((*head = (LSNode *)malloc(sizeof(LSNode))) == NULL) exit(1);(*head)->next = NULL;}/*判非空操作：*/int StackNotEmpty(LSNode *head)/*判堆栈是否非空，非空返回1；空返回0*/{if(head->next == NULL) return 0;else return 1;}/*入栈操作：*/int StackPush(LSNode *head, DataType x)/*把数据元素x插入链式堆栈head的栈顶作为新的栈顶*/{LSNode *p;if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL){printf("存空间不足无法插入! \n");return 0;}p->data = x;p->next = head->next; /*新结点链入栈顶*/head->next = p; /*新结点成为新的栈顶*/ return 1;}/*出栈操作：*/int StackPop(LSNode *head, DataType *d)/*出栈并把栈顶元素由参数d带回*/{LSNode *p = head->next;if(p == NULL){printf("堆栈已空出错！");return 0;}head->next = p->next; /*删除原栈顶结点*/*d = p->data; /*原栈顶结点元素赋予d*/ free(p); /*释放原栈顶结点存空间*/ return 1;}/*取栈顶数据元素操作：*/int StackTop(LSNode *head, DataType *d)/*取栈顶元素并把栈顶元素由参数d带回*/{LSNode *p = head->next;if(p == NULL){printf("堆栈已空出错！");return 0;}*d = p->data;return 1;}/*撤销*/void Destroy(LSNode *head){LSNode *p, *p1;p = head;while(p != NULL){p1 = p;p = p->next;free(p1);}}（2）主函数程序：#include<stdio.h>#include<stdlib.h>typedef int DataType;#include "LinStack.h"void main(void){ LSNode *myStack;int i, x;StackInitiate(&myStack);for(i=0;i<5; i++){ if(StackPush(myStack,i+1)==0){printf("error!\n");return;}}if(StackTop(myStack, &x)==0){printf("error!\n");return;}elseprintf("The element of local top is :%d\n",x);printf( "The sequence of outing elements is:\n");while(StackNotEmpty(myStack)){StackPop(myStack, &x);printf("%d ", x);}printf("\n");Destroy(myStack);printf("This program is made by10273206\n"); }运行结果为：（3）设计结构体和测试函数如下：#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct{char taskName[10];int taskNo;}DataType;#include"LinStack.h"void main(){LSNode *myStack;FILE *fp;DataType task,x;if((fp=fopen("task.txt","r"))==NULL){printf("不能打开文件task.txt!\n");exit(0);}StackInitiate(&myStack);while(!feof(fp)){fscanf(fp,"%s %d",&task.taskName,&task.taskNo);StackPush(myStack,task);}fclose(fp);while(StackNotEmpty(myStack)){StackPop(myStack,&x);printf("%s %d\n",x.taskName,x.taskNo);}Destroy(myStack);printf("This program is made by 10273206\n");}运行结果为：3-19（1）typedef struct{DataType queue[MaxQueueSize];int front; /*队头指针*/int count; /*计数器*/} SeqCQueue;/*初始化操作：QueueInitiate(SeqCQueue *Q) */void QueueInitiate(SeqCQueue *Q)/*初始化顺序循环队列Q */{Q->front=0; /*定义初始队头指针下标*/Q->count=0; /*定义初始计数器值*/}/*判非空否操作：QueueNotEmpty(SeqCQueue Q)*/ int QueueNotEmpty(SeqCQueue Q)/*判断顺序循环队列Q非空否，非空时返回1，否则返回0 */{if(Q.count!=0)return 1;else return 0;}/*入队列操作：QueueAppend(SeqCQueue *Q, DataType x)*/int QueueAppend(SeqCQueue *Q, DataType x)/*把数据元素x插入顺序循环队列Q的队尾，成功时返回1，否则返回0 */ {if(Q->count==MaxQueueSize){printf("The queue is full!\n");return 0;}else{ int r;r=Q->front+Q->count;Q->queue[r]=x;Q->count++;return 1;}}/*出队列操作：QueueDelete(SeqCQueue *Q, DataType *d)*/int QueueDelete(SeqCQueue *Q, DataType *d)/*删除顺序循环队列队头数据元素并赋值d，成功时返回1，否则返回0 */ {if(Q->count==0){printf("The queue is empty!\n");return 0;}else{*d=Q->queue[Q->front];Q->front=(Q->front+1)%MaxQueueSize;Q->count--;return 1;}}/*取对头数据元素操作：QueueGet(SeqCQueue Q, DataType *d)*/int QueueGet(SeqCQueue Q, DataType *d)/* 取顺序循环队列队头数据元素并赋值d，成功时返回1，否则返回0 */ {if(Q.count==0){printf("The queue is empty!\n");return 0;}else{*d=Q.queue[Q.front];return 1;}}（2）主函数程序：#include<stdio.h>#define MaxQueueSize 100typedef int DataType;#include"SeqQueue.h"void main(void){int i,j,d;SeqCQueue myQueue;QueueInitiate(&myQueue);if(QueueNotEmpty(myQueue)==0)printf("队列为空！请输入数据元素：\n"); /*判空*/for(i=0;i<=10;i++){if(QueueAppend(&myQueue,i+1)==0)break;}printf("元素个数为%d\n",myQueue.count); /*输出元素个数*/for(j=0;j<=9;j++){if(QueueDelete(&myQueue,&d)==0)break;printf("%d ",d); /*出队列并显示元素*/ }printf("\n");if(QueueNotEmpty(myQueue)==1)printf("队列不为空\n"); /*再次判空*/printf("This program is made by 10273206\n");}运行结果为：总结与思考对于堆栈和队列实验的操作，我明白了栈和队列这两种特殊线性结构的特性，初步掌握了栈在顺序存储结构和链表存储结构下的基本运算。
数据结构实验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<<"种摆放方法。
《数据结构 (c语言版)》实验二 栈和队列
（2）一个程序中如果要用到两个栈时，可通过两个栈共享一维数组来实现。即双向栈共享邻接空间。如果一个程序中要用到两个队列，能否实现？如何实现？
六、实验报告
1.程序要添加适当的注释，程序的书写要采用缩进格式。
2.程序要具在一定的健壮性，即当输入数据非法时，程序也能适当地做出反应，如插入删除时指定的位置不对等等。
case 1:
StackDisplay(St);
break;
case 2:
printf("请输入要入栈的元素(一个整数):");
scanf("%d",&e); //输入要入栈的元素
temp=Push(St,e); //入栈
if(temp!=OK) printf("堆栈已满!入栈失败!\n");
else {
（一）实验内容
1.编写一个程序实现顺序栈的各种基本运算。
2.实现队列的链式表示和实现。
（二）实验步骤
1.初始化顺序栈
2.插入元素
3.删除栈顶元素
4.取栈顶元素
5.遍历顺序栈
6.置空顺序栈
7.初始化并建立链队列
8.入链队列
9.出链队列
10.遍历链队列
（三）实验提示
1./*定义顺序栈的存储结构*/
typedef struct {
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
* S.top ++ = e;
return OK;
}//Push
数据结构栈和队列实验报告
数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。
通过编程实现栈和队列的相关操作，加深对其特性的认识，并能够运用栈和队列解决实际问题。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理（一）栈栈（Stack）是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
可以将栈想象成一个只有一端开口的容器，元素只能从开口端进出。
入栈操作（Push）将元素添加到栈顶，出栈操作（Pop）则从栈顶移除元素。
（二）队列队列（Queue）也是一种线性表，但其操作遵循“先进先出”（FirstIn First Out，FIFO）的原则。
队列就像是排队买票的队伍，先到的人先接受服务。
入队操作（Enqueue）将元素添加到队列的末尾，出队操作（Dequeue）则从队列的头部移除元素。
四、实验内容（一）栈的实现与操作1、定义一个栈的数据结构，包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。
2、实现入栈（Push）操作，当栈未满时，将元素添加到栈顶，并更新栈顶指针。
3、实现出栈（Pop）操作，当栈不为空时，取出栈顶元素，并更新栈顶指针。
4、实现获取栈顶元素（Top）操作，返回栈顶元素但不进行出栈操作。
5、实现判断栈是否为空（IsEmpty）和判断栈是否已满（IsFull）的操作。
（二）队列的实现与操作1、定义一个队列的数据结构，包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。
2、实现入队（Enqueue）操作，当队列未满时，将元素添加到队尾，并更新队尾指针。
3、实现出队（Dequeue）操作，当队列不为空时，取出队头元素，并更新队头指针。
4、实现获取队头元素（Front）操作，返回队头元素但不进行出队操作。
5、实现判断队列是否为空（IsEmpty）和判断队列是否已满（IsFull）的操作。
栈和队列基本操作实验报告
栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(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. 还会有数据移动吗,为什么,答:栈的顺序存储不会有数据移动，移动的只是指向该数据地址的指针。
数据结构上机实验二-栈和链队列
数据结构上机实验二-栈和链队列数据结构上机实验二实验内容:栈和链队列的基本操作实验目的: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）假设以Ｉ和Ｏ分别表示入栈和出栈操作。
栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由Ｉ和Ｏ组成的序列，称可以操作的序列为合法序列，否则为非法序列。
编写一个算法，判断所给的序列S1：ＩＯＯＩＩＯＩＯＯ，S２：ＩＯＯＩＯＩＩＯ及S３：ＩＩＩＯＩＯＩＯ，S４：ＩＩＩＯＯＩＯＯ是否合法。
（1分）（4）二项式(a+b)n展开后，其系数构成杨辉三角形，利用队列写出打印杨辉三角形的前n行的程序。
（1分）1111211331……（5）基于堆栈，编写迷宫求解程序。
数据结构实验报告二(栈、队列与杨辉三角)
《数据结构》实验报告项目名称栈、队列与杨辉三角专业班级软件工程工科试验班学号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;}。
(数据结构)实验2 堆栈与队列
实验2 堆栈与队列
实验目的
1．会定义顺序栈和链栈的结点类型。
2．掌握栈的插入和删除结点在操作上的特点。
3．熟悉对栈的一些基本操作和具体的函数定义。
4．会定义顺序队列和链队列的结点类型。
实验内容
程序1 舞伴问题
（1）问题描述
假设在周末舞会上，男士和女士进入舞厅时，各自排成一队。
跳舞开始时，依次从男队和女队的队头上各出一个配成舞伴。
若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。
编写程序模拟上述舞伴配对问题。
（2）问题分析
根据问题描述可知，新来人员将根据性别分别在队尾插入到男队或女队。
排在队头的男士或女士优先出队，并与另一个队中的队头成员组成舞伴。
由此可见，舞伴问题中的成员关系存在着先进先出的特点，可以采用队列这种数据结构来存储两队信息。
舞伴问题中，不断有队头成员出队组成新的舞伴及新成员在队尾插入的操作，如果采用的顺序队列，由于队头元素删除后，存储空间的不可重复操作性，将导致存储空间浪费，从而造成假溢出现象的发生。
根据以上分析，采用循环队列进行存储。
程序2回文数
由于输入的一个回文数可能无穷大，所以要求使用单链表存储该数。
[问题描述]
将用户输入的数以一个单链表的方式存储。
从头扫描该单链表，将前面的一半元素入栈，若元素的总个数为奇数，则跳过中间的那个元素，然后开始循环：边退栈边在单链表中后移指针，若当前栈顶元素与单链表中当前节点的值域不相等，则退出循环。
最后如果栈空且链表比较完毕，则是回文数，否则不是回文数。
实验二_栈与队列的基本操作与实现
实验二栈与队列的基本操作与实现一、实验目的：利用高级程序设计语言来实现抽象数据类型栈与队列，进一步熟悉其表示和实现方法，用已经实现的操作来组合新的操作，为以后的利用栈和队列分析和解决问题打下基础。
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数据结构实验报告二(栈和队列及其应用)
实验二 栈和队列及其应用、实验目的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 版本可编辑.欢迎下载支持.做实验首先要掌握大量的理论知识，大的困难，这就要需要我们的毅力。
北邮数据结构实验报告二_栈和队列
2009级数据结构实验报告实验名称：实验二栈和队列学生姓名：班级：班内序号：学号：日期：2010年12月18日实验要求题目四用栈做计算器。
设计一个算术四则运算表达式求值的简单计算器。
表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。
基本要求：输入中缀表达式能够转化成后缀表达式，比如输入中缀表达式“(A+B)*C”，输出“AB+C*”2、操作数使用单字母变量A、B、C等表示，操作符仅为+、-、*、/、（和）；3、能够对变量A、B、C等赋值，得出正确的计算结果2. 程序分析首先，程序要求用户输入一个符号表达式，只能包含字母、+、-、*、/ 以及）和（，之后程序会用一个TurnInfixToPostfix（）函数将表达式转化成后缀表达式存入一个栈中，转化过程借用逆波兰算法，建立一个符号栈，遍历用户输入的表达式，如果是字母，则直接输出，如果是运算符，则压入符号栈中（包括括号），在压栈的时候又需要注意，先要检查压栈前栈顶元素的优先级，如果优先级高于要压入的符号则直接压入该符号，否则要弹栈直到栈顶元素的优先级小于该元素的优先级然后才将该符号压入栈中（在压栈的时候会涉及到栈中有括号的情况，具体细节下面会说到），将转化的后缀表达式存入栈postfix，在输出的时候只要弹栈就行。
然后，要求用户逐个输入表达式中的字母的值，这时候，需要遍历当时在转化后缀表达式的时候过度容器vec_intoposfix，如果是字母则要求用户输入数值，压入用于计算的后缀表达式容器，如果是操作符则直接压入。
最后，在利用栈来计算值的时候，利用一个递归函数，就是一次弹栈，如果是操作符则先保存起来，接着继续弹栈，如果接下来的两个元素都为数字，就将这两个数字做相应的运算，然后压栈，如此反复，最后压入栈的元素就是表达式的值。
至此，程序的功能全部实现。
2.1 存储结构[内容要求]1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59页图2-92.2 关键算法分析关键算法一：将中缀表达式转化为后缀表达式VoidTurnInfixToPostfix(vector<char>&vec,stack<char>&sta,vector<char>&vecfix,stack< char>&stafix)1、 {2、int priority(-1);3、4、for (vector<char>::iterator itr=vec.begin();itr!=vec.end();itr++)5、{6、if(isLetter(*itr))7、{8、vecfix.push_back(*itr);9、}10、if (isOperator(*itr))11、{12、if(!sta.empty()) priority=getPriority(sta.top());13、else priority=-1;14、if (priority<getPriority(*itr)||priority==3&&sta.top()!=')')15、{16、sta.push(*itr);17、}18、else19、{20、if (sta.top()!=')')21、{22、while(priority>=getPriority(*itr)&&sta.top()!='(')23、{24、vecfix.push_back(sta.top());25、if (!sta.empty())26、{27、sta.pop();28、if(!sta.empty()) priority=getPriority(sta.top());29、else priority=-1;30、}31、else32、break;33、}34、sta.push(*itr);35、}36、else if(sta.top()==')')37、{38、while (sta.top()!='(')39、{40、vecfix.push_back(sta.top());41、if (!sta.empty()&&sta.top()!='(')42、{43、sta.pop();44、}45、else46、break;47、}48、}49、}50、51、52、}53、54、}55、for (vector<char>::iteratoritrfix=vecfix.end();itrfix!=vecfix.begin();--itrfix)56、stafix.push(*itrfix);57、stafix.push(*itrfix);58、}对表达式a + b * c – ( d – e) / f + g其符号栈的变化过程，红色表示未压栈的符号。
数据结构实验二题目一栈和队列实验报告
{if(top2==seqstack) throw "下溢";
cout<<data[top2]<<e ndl;
}
}
B、实现一个链栈
插入删除
a伪代码实现
入栈：生成新结点，对新结点赋值，新结点的指向原栈顶指针，修改栈顶指针为新结点。
出栈：判断若为空栈抛出下溢异常，保存栈顶元素，建立新结点，保存栈顶指针，修改栈顶 指针为原栈顶指针的下一个结点，删除栈顶指针并输出栈顶元素。
void shareseqstack::push(i nt x,i nt push nu mber)//进栈操作
{if(top1+1==top2)〃异常处理
throw "上溢”;
if(pushnumber==1)〃判断栈1还是栈2
data[++top1]=x;
if(push nu mber==2)
data[__top2]=x;
{if(top2==seqstack) throw "下溢";
else cout<<data[top2++]<<e ndl;
}
}
void shareseqstack::gettop(i nt get nu mber)//得至U栈顶元素
{if(getnumber==1)//判断栈1还是栈2
{if(top1==-1) throw "下溢";//异常处理cout<<data[top1]<<e ndl;}
b、算法实现:void lin kstack::push( int x)//进栈操作
数据结构实验——栈和队列
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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二栈和队列的基本操作及其应用
一、实验目的
1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。
2、掌握栈和队列的特点，即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序
存储结构和链式存储结构上的实现。
二、实验内容
本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，学生
可以根据自己的情况任选一个！
题目一：回文判断（*）
[问题描述]
对于一个从键盘输入的字符串，判断其是否为回文。
回文即正反序相同。
如
“abba”是回文，而“abab”不是回文。
[基本要求]
（1）数据从键盘读入；
（2）输出要判断的字符串；
（3）利用栈的基本操作对给定的字符串判断其是否是回文，若是则输出
“Yes”，否则输出“No”。
[测试数据]
由学生任意指定。
题目二：顺序栈和循环队列基本操作（*）
[基本要求]
1、实现栈的基本操作
六项基本操作的机制是：初始化栈：init_stack(S)；判断栈空：stack_empty(S)；取栈顶元素：stack_top(S,x)；入栈：push_stack(S,x)；出栈：pop_stack(S)；判断栈满：stack_full(S)
2、实现队列的基本操作
六项基本操作的机制是：初始化队列：init_queue(Q)；判断队列是否为空：queue_empty(Q)；取队头元素：queue_front(Q,x)；入队：enqueue(Q,x)；出队：outqueue(Q,x)；判断队列是否为满：queue_full(Q)
[测试数据]
由学生任意指定。
题目三：商品货架管理（**）
[问题描述]
商店货架以栈的方式摆放商品。
生产日期越近的越靠近栈底，出货时从栈顶取货。
一天营业结束，如果货架不满，则需上货。
入货直接将商品摆放到货架上，则会使生产日期越近的商品越靠近栈顶。
这样就需要倒货架，使生产日期越近的越靠近栈底。
[基本要求]
设计一个算法，保证每一次上货后始终保持生产日期越近的商品越靠近栈底。
[实现提示]
可以用一个队列和一个临时栈作为周转。
[测试数据]
由学生任意指定。
三、实验前的准备工作
1、掌握栈的逻辑结构和存储结构。
2、熟练掌握栈的出栈、入栈等操作。
3、掌握队列的逻辑结构和存储结构。
4、熟练掌握队列的出队、入队等操作
四、实验报告要求
1、实验报告要按照实验报告格式规范书写。
*2、写出算法设计思路。
3、实验上要写出多批测试数据的运行结果。
4、结合运行结果，对程序进行分析。
题目四：Rails（ACM训练题）
Description
There 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 that time. 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.
Input
The 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.
Output
The 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 Input
5
1 2 3 4 5
5 4 1 2 3
6
6 5 4 3 2 1
Sample Output Yes
No
Yes。