2栈的应用上机实验要求
实验二 栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用一、实验目的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;}。
栈的基本操作指导
实验2栈的基本操作实验指导1.实验内容基本内容：输入一个中缀一位整数算术表达式，先将其转换为后缀表达式，转换的方法采用栈实现，并且考虑算符的优先级，然后用另一个栈来计算后缀表达式的值。
对输入的表达式，做如下假设：(1)只考虑+、-、*、/这四种运算符；(2)输入的中缀表达式中数字是一位整数，没有小数；(3)假定输入表达式是合法的。
2.测试用例中缀表达式：3*4-5+7#后缀表达式：34*5-7+测试结果：143.算法描述计算中缀算术表达式是有关栈的经典算法题，很多公司面试或者笔试的时候都会把计算中缀表达式作为一个考察点。
这里先讨论如何直接计算中缀表达式的值，再讨论如何把中缀表达式转化为后缀表达式，最后计算后缀表达式。
3.1直接计算中缀表达式设置两个工作栈，一个操作数栈，一个操作符栈，在（自左至右）扫描算术表达式时，遇到操作数直接入操作数栈，若遇到操作符，则根据操作符优先级判断下一步操作（“操作符优先级规则”）：若其优先级高于栈顶操作符，则入栈，否则（相等或小于），弹出栈顶算符，并从操作数栈弹出两个操作数，计算，将计算结果入操作数栈，继续比较与栈顶操作符的优先级，若仍然等于或低于之，则计算，直至大于之，则将此操作符入栈；左括号一定入栈，且其优先级低于后续来到的任何操作符，右括号一定出栈并计算直至遇到左括号，另外栈的开始以“#”开始，算术表达式以“#”结束，做结束标志。
当栈空时，计算结束。
3.2 中缀表达式转为后缀表达式中缀转化为后缀，要先设一个栈存储运算符，从左到右遍历表达式，主要遵循以下原则：（1）读到操作数，直接输出；（2）栈为空时，遇到运算符，入栈；（3）遇到左括号，将其入栈；（4）遇到右括号，执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出，左括号也要弹出；（5）遇到其他运算符’+”-”*”/’时，弹出所有优先级大于或等于该运算符的栈顶元素，然后将该运算符入栈，遇到左括号时不能再弹出；（6）最终将栈中的元素依次出栈，输出。
实验二 栈和队列的基本操作及其应用
实验二栈和队列的基本操作及其应用一、实验目的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”表现不是回文。
实验2栈实验报告
实验2 栈实验报告1. 实验目的通过本次实验，使学生了解栈的基本概念和应用，掌握栈的操作算法，培养学生的编程能力和算法思维。
2. 实验环境•编程语言：C/C++•开发工具：Visual Studio/Code/GCC•操作系统：Windows/Linux/macOS3. 实验内容本次实验主要包括以下几个方面的内容：1.实现一个简单的栈数据结构；2.实现栈的常见操作（如入栈、出栈、判空、长度等）；3.利用栈解决括号匹配问题；4.利用栈实现逆波兰表达式求值；5.分析栈在函数调用中的应用。
4. 实验步骤4.1 栈的定义与实现首先，我们需要定义一个栈的数据结构。
在C/C++中，可以使用数组或链表来实现栈。
这里我们使用数组来实现。
#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;接下来，我们需要实现栈的常见操作。
入栈（push）void push(Stack* s, int value) {if (s->top >= MAX_SIZE - 1) {printf("栈已满，无法入栈\n");return;s->data[++s->top] = value;出栈（pop）int pop(Stack* s) {if (s->top < 0) {printf("栈已空，无法出栈\n");return -1;return s->data[s->top--];判空（isEmpty）int isEmpty(Stack* s) {return s->top < 0;获取栈长度（length）int length(Stack* s) {return s->top + 1;4.2 括号匹配问题括号匹配问题是栈的一个经典应用。
数据结构实验二 栈基本操作
实验二栈基本操作一、实验目的掌握栈的基本操作：初始化、判空、判满、入栈、出栈、取栈顶元素等运算。
二、实验要求包含有头文件和main函数；1.格式正确，语句采用缩进格式；2.设计子函数实现题目要求的功能；3.编译、连接通过，熟练使用命令键；4.运行结果正确，输入输出有提示，格式美观。
三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤实验内容：1.分析程序。
2.完成程序编写和补充步骤：3.确定数据的结构；4.利用main函数调用各子函数；5.调试、分析运行结果。
五、实验报告要求1.根据实验内容初步设计好程序，并从理论上排除错误；2.针对程序的健壮性准备好测试数据；3.结果分析中如实填写运行后的结果，记录调试过程中产生的重要问题和解决方法。
六、根据实验过程填写下面内容基础部分1.构建下列头文件，文件名称seqstack.h#define TRUE 1#define FALSE 0#define Stack_Size 500#define StackElementType inttypedef struct{StackElementType elem[Stack_Size]; /*用来存放栈中元素的一维数组*/int top; /*用来存放栈顶元素的下标，top为-1表示空栈*/}SeqStack;void InitStack(SeqStack *S){ S->top = -1; }int IsEmpty(SeqStack *S) /*判断栈S为空栈时返回值为真，反之为假*/{ return(S->top==-1?TRUE:FALSE);}int IsFull(SeqStack *S) /*判断栈S为满栈时返回值为真，反之为假*/{ return(S->top==Stack_Size-1?TRUE:FALSE);}int Push(SeqStack *S,StackElementType x){ if(S->top==Stack_Size-1)return(FALSE); /*栈已满*/S->top++;S->elem[S->top] = x;return(TRUE);}int Pop(SeqStack *S,StackElementType *x){ if(S->top == -1) /*栈为空*/return(FALSE);else{*x = S->elem[S->top];S->top--; /* 修改栈顶指针*/return(TRUE);}}int GetTop(SeqStack *S,StackElementType *x){ if(S->top == -1) /*栈为空*/return(FALSE);else{ *x = S->elem[S->top];return(TRUE); }}2.构建判断回文序列的程序，完成运行和调试。
栈的表示与实现及栈的应用实验报告参考模板
实验二：栈的表示与实现及栈的应用【实验目的】（1） 掌握栈的顺序存储结构及其基本操作的实现。
（2） 掌握栈后进先出的特点，并利用其特性在解决实际问题中的应用。
（3） 掌握用递归算法来解决一些问题。
【实验内容】1. 编写程序，对于输入的任意一个非负十进制整数，输出与其等值的八进制数。
2. 编写递归程序，实现N ！的求解。
3. 编写递归程序，实现以下函数的求解。
4. 编写程序，实现Hanoi 塔问题。
【实验步骤】1.打开VC++。
2.建立工程：点File->New ，选Project 标签，在列表中选Win32 Console Application ，再在右边的框里为工程起好名字，选好路径，点OK->finish 。
至此工程建立完毕。
3.创建源文件或头文件：点File->New ，选File 标签，在列表里选C++ Source File 。
给文件起好名字，选好路径，点OK 。
至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码5．编译－＞链接－＞调试1、#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1⎩⎨⎧>-+-==1),2()1(0,1,)(n n Fib n Fib n n n Fib#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int SElemType;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S){S.base=(SElemType *)malloc (STACK_INIT_SIZE*sizeof(SElemType));if (!S.base) return OVERFLOW;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}//InitStackStatus 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) exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;} //PUSHStatus Pop(SqStack &S, SElemType &e) {if(S.top==S.base)return ERROR;e=*--S.top;return OK;} //PopStatus StackEmpty(SqStack S){if (S.top==S.base)return OK;elsereturn ERROR;} //StackEmptyvoid conversion(){int N;int e;SqStack S;InitStack(S);printf("输入要转换的数据：");scanf("%d",&N);while (N){Push(S, N % 8);N = N/8;}printf("\n其对应的八进制数是：");while (!StackEmpty(S)){Pop(S,e);printf ( "%d", e );}}void main(){conversion();}2、#include <stdio.h>Int fact(int n){If(n==1)return 1;elsereturn n*fact(n-1);}void main(){Int n;printf(“输入一个数n:”);scanf(“%d”,&n);printf("fact(%d)=%d\n",n,fact(n)); }3、#include <stdio.h>int fib(int n){if(n>1)return fib(n-1)+fib(n-2);elsereturn n;}void main(){int n;printf("\n输入一个数n:");scanf("%d",&n);printf("fib(%d)=%d\n",n,fib(n));}4、#include <stdio.h>void move(char x,int n,char z){printf("将%d号盘从%c柱移到%c柱\n",n,x,z);}void hanoi (int n, char x, char y, char z) { if (n==1)move(x,1,z);else{hanoi(n-1, x, z, y);move(x, n, z);hanoi(n-1, y, x, z);}}void main(){int n;scanf("%d",&n);hanoi(n,'x','y','z');}【实验心得】这节课的实验内容是栈的表示与实现及栈的应用。
栈的操作(实验报告范文)
栈的操作(实验报告范文)栈的基本操作,附带源程序实验三栈和队列3.1实验目的：（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。
3.2实验要求：（1）复习课本中有关栈和队列的知识；（2）用C语言完成算法和程序设计并上机调试通过；（3）撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
3.3基础实验[实验1]栈的顺序表示和实现实验内容与要求:编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化顺序栈（2）插入元素（3）删除栈顶元素（4）取栈顶元素（5）遍历顺序栈（6）置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。
对于顺序栈，入栈时，首先判断栈是否为满，栈满的条件为：p->top==MA某NUM-1，栈满时，不能入栈;否则出现空间溢出，引起错误，这种现象称为上溢。
出栈和读栈顶元素操作，先判栈是否为空，为空时不能操作，否则产生错误。
通常栈空作为一种控制转移的条件。
注意：（1）顺序栈中元素用向量存放（2）栈底位置是固定不变的，可设置在向量两端的任意一个端点（3）栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top （通常称top为栈顶指针）来指示当前栈顶位置参考程序:#include<tdio.h>#include<tdlib.h>#defineMA某NUM20栈的基本操作,附带源程序#defineElemTypeint/某定义顺序栈的存储结构某/ typedeftruct{ElemTypetack[MA某NUM]; inttop;}SqStack;/某初始化顺序栈某/voidInitStack(SqStack某p){if(!p)printf("Eorror");p->top=-1;}/某入栈某/voidPuh(SqStack某p,ElemType某){if(p->top<MA某NUM-1){p->top=p->top+1;p->tack[p->top]=某;}eleprintf("Overflow!\n");}/某出栈某/ElemTypePop(SqStack某p){ElemType某;if(p->top!=0){某=p->tack[p->top];printf("以前的栈顶数据元素%d已经被删除！\n",p->tack[p->top]);p->top=p->top-1;return(某);}ele{printf("Underflow!\n");return(0);}}/某获取栈顶元素某/ ElemTypeGetTop(SqStack某p) {ElemType某;if(p->top!=0){某=p->tack[p->top];return(某);}ele{printf("Underflow!\n");栈的基本操作,附带源程序return(0);}}/某遍历顺序栈某/ voidOutStack(SqStack某p) {inti;if(p->top<0)printf("这是一个空栈！");printf("\n");for(i=p->top;i>=0;i--)printf("第%d个数据元素是：%6d\n",i,p->tack[i]); }/某置空顺序栈某/voidetEmpty(SqStack某p){p->top=-1;}/某主函数某/main(){SqStack某q;inty,cord;ElemTypea;do{printf("\n");printf("第一次使用必须初始化！\n");printf("\n主菜单\n");printf("\n1初始化顺序栈\n");printf("\n2插入一个元素\n");printf("\n3删除栈顶元素\n");printf("\n4取栈顶元素\n");printf("\n5置空顺序栈\n");printf("\n6结束程序运行\n");printf("\n--------------------------------\n"); printf("请输入您的选择(1,2,3,4,5,6)");canf("%d",&cord);printf("\n");witch(cord){cae1:{q=(SqStack某)malloc(izeof(SqStack));InitStack(q);OutStack(q);}break;cae2:栈的基本操作,附带源程序{printf("请输入要插入的数据元素：a="); canf("%d",&a);Puh(q,a);OutStack(q);}break;cae3:{Pop(q);OutStack(q);}break;cae4:{y=GetTop(q);printf("\n栈顶元素为：%d\n",y); OutStack(q);}break;cae5:{etEmpty(q);printf("\n顺序栈被置空！\n"); OutStack(q);}break;cae6:e某it(0);}}while(cord<=6);}[实验2]栈的链式表示和实现实验内容与要求:编写一个程序实现链栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化链栈（2）链栈置空（3）入栈（4）出栈（5）取栈顶元素（6）遍历链栈分析:链栈是没有附加头结点的运算受限的单链表。
数据结构上机实验报告
数据结构上机实验报告数据结构上机实验报告1. 实验目的数据结构是计算机科学中非常重要的一门课程，通过本次上机实验，旨在帮助学生巩固和应用所学的数据结构知识，培养学生分析和解决实际问题的能力。
2. 实验背景本次实验涉及到两个常用的数据结构：栈和队列。
栈是一种后进先出（Last In First Out，LIFO）的数据结构，而队列是一种先进先出（First In First Out，FIFO）的数据结构。
通过实验，我们将学习如何使用这两种数据结构来解决实际问题。
3. 实验内容本次实验分为两个部分：栈的应用和队列的应用。
3.1 栈的应用在栈的应用部分，我们将实现一个简单的括号匹配算法。
该算法可以判断一个字符串中的括号是否匹配。
具体实现步骤如下：3.1.1 创建一个栈来存储括号字符；3.1.2 遍历字符串中的每个字符；3.1.3 如果遇到左括号，则将其入栈；3.1.4 如果遇到右括号，则判断栈顶元素是否是对应的左括号；3.1.5 如果栈为空或栈顶元素不是对应的左括号，则括号不匹配；3.1.6 如果栈顶元素是对应的左括号，则将其出栈；3.1.7 遍历完字符串后，如果栈为空，则括号匹配，否则括号不匹配。
通过实现这个算法，我们可以学习到如何使用栈来解决实际问题，并且理解栈的后进先出的特性。
3.2 队列的应用在队列的应用部分，我们将实现一个简单的任务调度算法。
该算法可以模拟多个任务按照一定的优先级进行调度的过程。
具体实现步骤如下：3.2.1 创建一个队列来存储任务；3.2.2 每个任务包含两个属性：任务名称和优先级；3.2.3 向队列中添加任务，并按照优先级进行排序；3.2.4 从队列中取出优先级最高的任务，并执行；3.2.5 执行完任务后，继续从队列中取出下一个优先级最高的任务，并执行，直到队列为空。
通过实现这个算法，我们可以学习到如何使用队列来实现任务调度，并且理解队列的先进先出的特性。
4. 实验结果与分析通过实验，我们成功实现了括号匹配算法和任务调度算法，并得到了正确的结果。
实验二 栈、队列的实现及应用
实验二栈、队列的实现及应用实验课程名：数据结构与算法专业班级：学号：姓名：/*构造空顺序栈*/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 SqStackreturn (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);//清除输入缓冲区，否则原来的输入会默认送给变量xprintf("请输入要入栈的元素的值:");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() endvoid 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 栈和队列的基本操作和应用1实验目的(1)熟练掌握顺序栈的基本操作。
(2)掌握顺序栈的应用。
(3)掌握顺序循环队列的基本操作。
(4)掌握链式队列的基本操作。
2实验内容(1)设计一个顺序栈的基本操作的演示程序；(2)利用顺序栈，进行整数的不同进制之间的转换；(3)设计一个顺序循环队列的基本操作演示程序；(4)设计一个链式队列的基本操作演示程序。
【基本要求】I.实验内容(1)的基本要求：编写一个程序，将一个顺序栈的元素依次取出，并打印其元素值。
II.实验内容(2)的基本要求：编写一个程序，将一个非负的十进制整数转换成二进制。
III.实验内容(3)的基本要求：编写一个程序，将一个顺序队列的元素依次取出，并打印其元素值。
IV.实验内容(4)的基本要求：编写一个程序，将一个链式队列的元素依次取出，并打印其元素值。
【测试数据】自定3实验结果按照学校实验格式要求撰写实验报告，内容主要包括1）实验目的；2）实验内容；3）实验环境和方法；4）实验过程描述；5）实验心得体会参考程序如下：实验内容（1）参考程序/*sqStack.h文件*/#define INIT_SIZE 100#define INCREMENT 10typedef int ElemType;//typedef char ElemType;typedef struct SqStack {ElemType *base;ElemType *top;int stacksize;}SqStack;enum Status{OK,ERROR,OVERFLOW};/*sqStackOp.h文件*/#include "sqStack.h"Status InitStack(SqStack &S) ;Status GetTop(SqStack S,ElemType &e);Status Push(SqStack &S,ElemType e);Status Pop(SqStack &S,ElemType &e);bool StackEmpty(SqStack &S);/*sqStackOp.cpp文件*/#include <malloc.h>#include <stdlib.h>#include "sqStackOp.h"Status InitStack(SqStack &S) {//构造一个空的栈S.base=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(! S.base) exit(OVERFLOW); //存储分配失败S.top=S.base;S.stacksize=INIT_SIZE;return OK;} //InitStackStatus GetTop(SqStack S,ElemType &e){//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;} //GetTopStatus Push(SqStack &S,ElemType e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){ //栈满，追加存储空间S.base=(ElemType *)realloc(S.base,(S.stacksize+INCREMENT)*sizeof(ElemType));if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=INCREMENT;}*S.top++=e;return OK;} //PushStatus Pop(SqStack &S,ElemType &e){//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERRORif(S.top==S.base) return ERROR;e=*(--S.top);return OK;} //Push//判断栈是否为空bool StackEmpty(SqStack &S){if(S.top == S.base)return true;elsereturn false;}/*main.cpp文件*/#include <stdio.h>#include <stdlib.h>#include "sqStackOp.h"void main(){printf("Hellow stack \n");SqStack S; //定义顺序栈Sif(OK != InitStack(S)) {printf("顺序栈初始化出错，退出....\n");exit(-1);}Push(S, 1);Push(S,2);Push(S,3);int e;Pop(S, e);printf("出栈元素= %d \n",e);Push(S,4);Push(S,5);while(!StackEmpty(S)){Pop(S, e);printf("出栈元素= %d \n",e);}/*SqStack S; char x,y;InitStack(S); x='c';y='k';Push(S,x); Push(S,'a'); Push(S,y);Pop(S,x); Push(S,'t'); Push(S,x);Pop(S,x); Push(S,'s');while(!StackEmpty(S)){ Pop(S,y);printf("%c ",y); };printf("%c ",x);*/getchar();}实验内容（2）参考程序/*sqStack.h文件*/#define INIT_SIZE 100#define INCREMENT 10typedef int ElemType;typedef struct SqStack {ElemType *base;ElemType *top;int stacksize;}SqStack;enum Status{OK,ERROR,OVERFLOW};/*sqStackOp.h文件*/#include "sqStack.h"Status InitStack(SqStack &S) ;Status GetTop(SqStack S,ElemType &e);Status Push(SqStack &S,ElemType e);Status Pop(SqStack &S,ElemType &e);bool StackEmpty(SqStack &S);/*sqStackOp.cpp文件*/#include <malloc.h>#include <stdlib.h>#include "sqStackOp.h"Status InitStack(SqStack &S) {//构造一个空的栈S.base=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(! S.base) exit(OVERFLOW); //存储分配失败S.top=S.base;S.stacksize=INIT_SIZE;return OK;} //InitStackStatus GetTop(SqStack S,ElemType &e){//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERRORif(S.top==S.base) return ERROR;e=*(S.top-1);return OK;} //GetTopStatus Push(SqStack &S,ElemType e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){ //栈满，追加存储空间S.base=(ElemType *)realloc(S.base,(S.stacksize+INCREMENT)*sizeof(ElemType));if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=INCREMENT;}*S.top++=e;return OK;} //PushStatus Pop(SqStack &S,ElemType &e){//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERRORif(S.top==S.base) return ERROR;e=*(--S.top);return OK;} //Push//判断栈是否为空bool StackEmpty(SqStack &S){if(S.top == S.base)return true;elsereturn false;}/*main.cpp文件*/#include <stdio.h>#include <stdlib.h>#include "sqStackOp.h"void main(){SqStack s;int x;InitStack(s);scanf("%d",&x); //%d--十进制输入；%O--八进制输入；%x--十六进制输入//修改这里输入进制和下面整除和余数计算，就可以获得其他进制的转换while(x!=0){Push(s,x%8);x=x/8;}while(!StackEmpty(s)){Pop(s,x);printf("%d ",x);}printf("\n");getchar();}实验内容（3）参考程序/*sqQueue.h 文件*/#define MAXQSIZE 100typedef int QElemType;typedef struct SqQueue {QElemType *base;int front;int rear;}SqQueue;enum Status{OK,ERROR,OVERFLOW};/*sqQueueOp.h 文件*/#include "sqQueue.h"Status InitQueue (SqQueue &Q) ;Status EnQueue (SqQueue &Q, QElemType e);Status DeQueue (SqQueue &Q, QElemType &e) ;bool QueueEmpty(SqQueue &Q);int QueueLength(SqQueue Q);/*sqQueueOp.cpp 文件*/#include <malloc.h>#include <stdlib.h>#include "sqQueueOp.h"Status InitQueue (SqQueue &Q) {// 构造一个空队列QQ.base = (QElemType *) malloc(MAXQSIZE *sizeof (QElemType));if (!Q.base) exit (OVERFLOW);// 存储分配失败Q.front = Q.rear = 0;return OK;}Status EnQueue (SqQueue &Q, QElemType e) { // 插入元素e为Q的新的队尾元素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) { // 若队列不空，则删除Q的队头元素，// 用e返回其值，并返回OK; 否则返回ERRORif (Q.front == Q.rear) return ERROR;e = Q.base[Q.front];Q.front = (Q.front+1) % MAXQSIZE;return OK;}//判断队列是否为空bool QueueEmpty(SqQueue &Q){if(Q.front== Q.rear)return true;elsereturn false;}//计算循环队列长度int QueueLength(SqQueue Q){return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;}/*main.cpp 文件*/#include <stdio.h>#include <stdlib.h>#include "sqQueueOp.h"void main(){printf("Hello Queue \n");SqQueue Q; //定义顺序队列QQElemType e;if(OK != InitQueue(Q)) {printf("顺序队列初始化出错，退出....\n");exit(-1);}EnQueue(Q,1);EnQueue(Q,3);EnQueue(Q,5);EnQueue(Q,7);printf("当前队列长度= %d \n",QueueLength(Q));DeQueue(Q,e);printf("队首元素%d出队，当前队列长度=%d\n",e,QueueLength(Q));EnQueue(Q,9);EnQueue(Q,11);while(!QueueEmpty(Q)){DeQueue(Q,e);printf("队首元素%d出队，当前队列长度=%d\n",e,QueueLength(Q));}getchar();}实验内容（4）参考程序/*linkQueue.h 文件*/typedef int QElemType;typedef struct QNode {// 结点类型QElemType data;struct QNode *next;} QNode, *QueuePtr;typedef struct { // 链队列类型QueuePtr front; // 队头指针QueuePtr rear; // 队尾指针} LinkQueue;enum Status{OK,ERROR,OVERFLOW};/*linkQueueOp.h 文件*/#include "linkQueue.h"Status InitQueue (LinkQueue &Q) ;Status EnQueue (LinkQueue &Q, QElemType e); Status DeQueue (LinkQueue &Q, QElemType &e) ; bool QueueEmpty(LinkQueue &Q);/*linkQueueOp.cpp 文件*/#include <malloc.h>#include <stdlib.h>#include "linkQueueOp.h"Status InitQueue (LinkQueue &Q) {// 构造一个空队列QQ.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if (!Q.front) exit (OVERFLOW);//存储分配失败Q.front->next = NULL;return OK;}Status EnQueue (LinkQueue &Q, QElemType e) { // 插入元素e为Q的新的队尾元素QueuePtr p = (QueuePtr) malloc (sizeof (QNode));if (!p) exit (OVERFLOW); //存储分配失败p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return OK;}Status DeQueue (LinkQueue &Q, QElemType &e) { // 若队列不空，则删除Q的队头元素，//用e 返回其值，并返回OK；否则返回ERROR if (Q.front == Q.rear) return ERROR;QueuePtr p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p) Q.rear = Q.front;free (p);return OK;}//判断队列是否为空bool QueueEmpty(LinkQueue &Q){if(Q.front == Q.rear)return true;elsereturn false;}/*main.cpp 文件*/#include <stdio.h>#include <stdlib.h>#include "linkQueueOp.h"void main(){printf("Hello LinkQueue \n");LinkQueue Q; //定义顺序队列QQElemType e;if(OK != InitQueue(Q)) {printf("顺序队列初始化出错，退出....\n");exit(-1);}EnQueue(Q,1);EnQueue(Q,3);EnQueue(Q,5);EnQueue(Q,7);DeQueue(Q,e);printf("队首元素%d出队，\n",e);EnQueue(Q,9);EnQueue(Q,11);while(!QueueEmpty(Q)){DeQueue(Q,e);printf("队首元素%d出队，\n",e);}getchar();}。
实验2栈的应用-算术表达式计算
实验2栈的应⽤-算术表达式计算浙江⼤学城市学院实验报告课程名称数据结构与算法实验项⽬名称实验⼆栈的应⽤---算术表达式的计算学⽣姓名蓝礼巍专业班级学号实验成绩指导⽼师（签名）⽇期⼀.实验⽬的和要求1．进⼀步掌握栈的基本操作的实现。
2．掌握栈在算术表达式的计算⽅⾯的应⽤。
⼆. 实验内容1. 编写程序利⽤栈将中缀表达式转换成后缀表达式，即从键盘输⼊任⼀个中缀表达式（字符串形式），转换成后缀表达式后，将后缀表达式输出。
假设：中缀表达式包含圆括号( ) 及双⽬运算符+、-、*、/、^（乘⽅）。
要求：把栈的基本操作的实现函数存放在头⽂件stack1.h中（栈元素的类型为char），在主⽂件test6_2.cpp中包含将中缀表达式S1转换成后缀表达式S2的转换函数void Change( char *S1, char *S2 )及主函数，在主函数中进⾏输⼊输出及转换函数的调⽤。
2. 选做：编写利⽤栈对后缀表达式进⾏求值的函数double Compute(char *str)，以计算从前述程序得到的后缀表达式的值。
要求：把栈的基本操作的实现函数存放在头⽂件stack2.h中（栈元素的类型为double），在主⽂件test6_2.cpp中添加后缀表达式求值函数，并在主函数中增加调⽤求值函数及输出结果值的语句。
3. 填写实验报告，实验报告⽂件取名为report2.doc。
4. 上传实验报告⽂件report2.doc与源程序⽂件stack1.h、stack2.h（若有）及test6_2.cpp到Ftp服务器上你⾃⼰的⽂件夹下。
三. 函数的功能说明及算法思路包括每个函数的功能说明，及⼀些重要函数的算法实现思路Void InitStack2(Stack2 &S)初始化void Push(Stack1 &S,ElemType1 item)元素插⼊ElemType1 Pop(Stack1 &S)删除栈顶并返回ElemType1 Peek(Stack1 &S)读取元素bool EmptyStack(Stack1 &S)判断是否为空void ClearStack(Stack1 &S)清除栈四. 实验结果与分析包括运⾏结果截图等五. ⼼得体会记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。
实验2 栈及其应用
实验二栈及其应用1．实验目的（1）掌握栈的特点及其描述方法。
（2）用链式存储结构实现一个栈。
（3）掌握建栈的各种等基本操作。
（4）掌握栈的几个典型应用的算法。
2.实验内容A.验证性部分（1）设计一个字符型的链栈；（2）编写进栈、出栈、显示栈中全部元素的程序；（3）编写一个把十进制整数转换成二进制数的应用程序；（4）设计一个选择式菜单，以菜单方式选择上述操作。
B.自主性实验部分（1）用键盘输入一个整数后缀表达式（操作数的范围是0～9，运算符只含+、-、*、/，而且中间不可以有空格），使用循环程序从左向右读入表达式。
（2）如果读入的是操作数，直接进入操作数栈。
（3）如果读入的是运算符，立即从操作数栈取出所需的操作数，计算操作数运算的值，并将计算结果存回操作数栈。
3．实验要求：(1)选择合适的存储结构（顺序栈或链式栈）表示栈，给出其定义。
(2)在上述存储结构上实现栈的基本操作：初始化、置栈空、入栈、出栈、取栈顶元素等。
（3）分析后缀表达式求值的算法思想，用C（或C++）语言设计程序。
（4）上机调试通过实验程序。
（5）给出具体的算法分析，包括时间复杂度和空间复杂度等。
（6）撰写实验报告。
4．实验预备知识（1）栈的定义及栈的“后进先出”的特点。
（2）栈的顺序存储与链式存储结构及栈的初始化、入栈、出栈、取栈顶等基本操作。
（3）算术表达式的三种表示形式（前缀式、中缀式、后缀式）。
5．实验环境（1）一台运行 Windows 2000/XP 操作系统的计算机（2）选用turbo c或visual c++6、实验说明（1）类型定义#define MAXSIZE 100 /*栈的最大值*/typedef struct{ElemType elem[MAXSIZE]；int top；}SqStack； /*顺序栈的类型定义*/（2）注意问题①重点理解栈的算法思想，能够根据实际情况选择合适的存储结构②栈的算法是后续实验的基础（广义表、树、图、查找、排序等）7．实验用测试数据和相关结果分析：（由学生填写）8．实验总结：（由学生填写）9．参考程序参考模板A．验证性实验程序模板#include <stdio.h>#include <stdlib.h>#include “链栈.h”#define MAXLEN 100void main(){int i=1,j=1,choice,val,n;char a;linkstack *s=new linkstack;s->top=NULL;while(i){printf("\n\n");printf("\n\t\t 链栈子系统\n");printf("\n\t\t*******************************");printf("\n\t\t* 1----入栈*");printf("\n\t\t* 2----出栈*");printf("\n\t\t* 3----显示栈*");printf("\n\t\t* 4----进制转换*");printf("\n\t\t* 0----返回*");printf("\n\t\t*******************************");printf("\n\t\t 请选择(0--4):");choice=getchar();getchar();switch (choice){case '1':while(j){printf("\t\t请输入一个整数(按回车输入下一个，输入'0'结束)：");scanf("%d",&val);getchar();if (val!=0)push(s,val);elsej=0;}break;case '2':if(s->top!=NULL) printf("出栈元素是：%6d\n",pop(s));break;case '3': showstack(s);break;case '4':printf("请输入待转换的数'n' 和进制'i':(n,i)\n");scanf("%d,%d",&n,&i);Conversion(i,n);break;case '0':i=0;break;default:;}if (choice=='1'||choice=='2'||choice=='3'||choice=='4'){printf("\n\t\t按回车键继续，按其它任意键返回！");a=getchar();if (a!='\xA')i=0;}}system("pause");}/*链栈头文件：链栈.h*/typedef char datatype;typedef struct stacknode{int data;struct stacknode *next;}stacknode;typedef struct{stacknode *top;}linkstack;void push(linkstack *s,int x) /*进栈*/{//请补充完善}int pop(linkstack *s) /*出栈*/{//请补充完善}void showstack(linkstack *s) /*显示栈元素*/{//请补充完善}void Conversion(int i,int n) /*进制转换*/{//请补充完善}B．自主性实验程序模板/*表达式求值程序*/#include"stdio.h"#include "stdlib.h"#include"string.h"#define MAXSIZE 100typedef char ElemType;#include "顺序栈.h"char operate(char a,char theta,char b) /*求两数a和b作θ运算的结果*/{int r;a=a-48;b=b-48;switch(theta){case '+':r=a+b;break;case '-':r=a-b;break;case '*':r=a*b;break;case '/':r=a/b;break;}return(r+48);}char precede(char theta1,char theta2) /*判断两个运算符θ1和θ2的优先关系*/{switch(theta1){case '+':case '-':{if(theta2=='+'||theta2=='-'||theta2==')'||theta2=='#')return('>');else if(theta2=='*'||theta2=='/'||theta2=='(')return('<');}case '*':case '/':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2==')'||theta2=='#')return('>');else if(theta2=='(')return('<');}case '(':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2=='(')return('<');else if(theta2==')')return('=');}case ')':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2==')'||theta2=='=')return('>');}case '=':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2=='(')return('<');else if(theta2=='=')return('=');}}}char Evaluation(char exp[20])/*返回由中缀式exp表示的算术表达式的运算结果。
实验二 栈的应用
实验二栈的应用一、实验目的掌握栈的基本操作：初始化栈、判栈为空、出栈、入栈等运算。
二、实验条件1、PC机2、软件Visual C++三、实验原理栈是限定只能在表的一端进行插入和删除的线性表。
我们要注意以下几点：（1）栈还是线性表，不过在操作中不能随心所欲，只能做限定的某些动作；（2）栈的操作原则是后进先出（LIFO）；（3）进栈和出栈只能从栈的一端进行，这端称为栈顶。
另外不能操作的一端叫栈底。
栈的中间亦不能进、出元素；（4）同一个栈中的元素类型是相同的。
栈的顺序存储结构中，规定了将变量top指向栈顶元素所在位置，这样方便操作，对top的上下移动就体现了进栈和出栈的动作。
注意栈的顺序存储结构在进栈出栈的时候要考虑栈满和栈空的情况。
栈的链式存储结构中，一样是采用单链表存储栈中的元素，并且规定了top 结点，类似单链表中的head结点，指向栈顶结点，进栈出栈都在表头进行。
这里结点的指针域指向的是次顶结点。
注意栈的链式存储结构在进栈时不需要考虑栈满的情况。
在分析实际问题时，如操作的对象符合“后出现的反而先处理”的情况，就可考虑用到栈来进行辅助设计。
如进制转换：（N表示任一十进制数，d表示进制）N = (N div d)×d + N mod d;1348 = 1348/8 * 8 +1348%8例：（1348）10 = （2504）8N (N div 8) N mod 81348 168 4168 21 021 2 52 0 2先进后出：数据生成的顺序：4,0,5,2读出的顺序：2,5,0,4四、实验内容与要求利用栈的基本操作实现将任意一个十进制整数转化为R进制整数。
五、算法分析1、定义栈的顺序存取结构2、分别定义栈的基本操作（初始化栈、判栈为空、出栈、入栈等）3、定义一个函数用来实现上面问题：十进制整数X和R作为形参初始化栈只要X不为0重复做下列动作:将X%R入栈；X=X/R只要栈不为空重复做下列动作:栈顶出栈；输出栈顶元素如输入一个非负的十进制数，输出等值的八进制数。
栈的应用实验报告
栈的应用实验报告实验目的：1.了解栈结构及其应用；2.通过实验加深对栈的理解；3.掌握栈的基本操作。
实验内容：1.实现栈的基本功能，包括入栈、出栈、获取栈顶元素、判断栈是否为空等；2.实现一些特殊功能，如：计算表达式的值、判断括号是否匹配等；3.应用栈实现前缀、中缀、后缀表达式之间的转换。
实验步骤：1.首先实现栈的基本功能，根据题目需求选择相应的数据结构，如：数组、链表等，我选择了数组。
定义栈的数据结构，包括：栈顶指针、栈的大小、栈中元素的个数等信息；2.实现入栈操作，即向栈中添加元素；3.实现出栈操作，从栈中取出元素；4.实现获取栈顶元素的操作，即查看栈顶元素，但不从栈中删除；5.实现判断栈是否为空的操作；6.实现计算表达式的值的操作。
7.实现括号匹配判断操作。
8.应用栈实现前缀、中缀、后缀表达式之间的转换。
实验结果：1.通过实验，我能够熟练掌握栈的基本操作，如入栈、出栈、获取栈顶元素、判断栈是否为空等。
2.通过对表达式的求值，我能够了解栈在计算机科学中的重要应用，能够解决表达式中优先级问题。
3.通过对括号匹配的判断，我能够更好地理解栈的后进先出的特性。
4.应用栈实现前缀、中缀、后缀表达式之间的转换，我能够更好地理解这三种表达式的区别，以及更好地理解栈的应用。
结论：通过这次实验，我对栈的理解更深入了。
栈是一种非常重要的数据结构，在计算机领域有着广泛的应用，如编译器、表达式计算、括号匹配等。
因此，掌握和熟练应用栈是非常有必要的。
希望以后在学习计算机相关知识的时候，能够多加使用和练习栈的相关操作。
实验二栈和队列基本操作与应用
实验二第三章 栈和队列上机实验实验时间与地点第一组和第二组时间： 2011-4-13，星期三， 3，4 节 10： 10— 11： 50； 地点：信息学院实验中心，弘毅楼 班级：信息 091-3 第一和第二小组； 实验内容【实验目的 】 深入理解栈和队列的特性，领会它的应用背景。
熟练掌握在不同存储结构、不同的约定 中，其基本操作的实现方法与差异。
并体会以下几点（注意你所做的约定） ：1、顺序栈（初始化、栈空 / 栈满条件，入栈 / 出栈）；2、链栈（初始化、栈空条件，入栈 / 出栈）；3、顺序队列4、链队列【实验选题 】 选题一、栈的基本操作的实现 （1 人 / 组） 实验 1 要求1． 会定义顺序栈和链栈的结点类型。
2． 掌握栈的插入和删除结点在操作上的特点。
3． 熟悉对栈的一些基本操作和具体的函数定义。
具体内容程序 1 该程序的功能是实现顺序栈的定义和操作。
该程序包括定义的栈结构类型以及对每一种 栈操作的具体的函数定义和主函数。
选题二、 队列基本操作的实现 （1 人 / 组）实验 2 要求4． 会定义顺序队列和链队的结点类型。
5． 掌握队列的插入和删除结点在操作上的特点。
6． 熟悉对队列的一些基本操作和具体的函数定义。
具体内容程序 1：链队列表示和实现程序 2：队列运算在顺序存储结构上的实现假定采用 Queue 记录类型的对象 Q 来表示顺序存储的队列，则在 Q 上进行各种队列运算实验过程要求1、 分组形式 ：学生自行分组，每组 3 人，汇总到课代表处，课代表在本周末前 mail 告 诉我；2、 组内分工与协作 ：1）同一小组的同学在上机前讨论确定问题可以采用的数据结构、流程的安排、模块 的划分等，共同完成上机前的准备工作，并对要编制的代码进行分工；2） 每个同学上机时完成自己那部分程序模块的编制和调试3） 同组同学在单体测试通过后，完成整个程序的联调；4） 联调通过后，检查上机结果，并可以进一步讨论该程序可以改进的地方或扩展的 功能及其方法。
3.3.2栈的应用教学设计
4.课后作业：教师对学生的课后作业进行批改和评价，了解学生对栈的应用的掌握程度和应用能力。
5.教师评价与反馈：教师根据以上评价结果，对学生进行综合评价，指出学生的优点和不足，并提出改进建议。同时，教师应鼓励学生积极思考，提出问题，提高学生的学习兴趣和主动性。
教学资源准备
1.教材：确保每位学生都有本节课所需的教材，如《高中信息技术》课本及相关学习资料，以便学生能够跟随教学进度进行学习和复习。
2.辅助材料：准备与教学内容相关的图片、图表、案例等多媒体资源，以便在教学过程中进行直观展示和解释，帮助学生更好地理解和掌握栈的应用。
3.实验器材：本节课可能需要涉及一些编程实践，因此需要准备计算机、编程环境等实验器材，确保实验器材的完整性和安全性，以便学生能够进行实际操作和练习。
（二）存在主要问题
1.教学管理：课堂纪律管理不够严格，部分学生上课注意力不集中。
2.教学方法：教学方法过于单一，缺乏与学生的互动和反馈。
3.教学评价：评价方式过于注重结果，忽视了学生的学习过程和能力培养。
（三）改进措施
1.加强课堂纪律管理，严格要求学生遵守课堂纪律，提高课堂效果。
2.采用多样化的教学方法，如提问、讨论、小组合作等，增加与学生的互动和反馈，提高学生的参与度。
对于对课程学习有积极影响的学生，我们可以设计更具挑战性的教学活动，如编程竞赛、实际项目开发等，以提高他们的学习兴趣和能力。对于对课程学习有困难的学生，我们需要关注他们的学习过程，提供更多的辅导和帮助，鼓励他们积极参与课堂讨论和实践活动，提高他们的学习兴趣和能力。同时，我们还需要关注学生的学习态度和行为习惯，引导他们树立正确的学习观念，培养良好的学习习惯。
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)问题描述：假设以键盘输入的方式输入一个正整数序列：比如x1, x2, x3，…，xn,要求算法实现：当ai≠0时，将ai进栈；当ai=0时，输出栈顶元素并出栈。
用栈结构存储所输入的整数序列，并且要求算法的健壮性及能够应对异常情况（如果是顺序要判断栈满栈空，如果是链式栈要判断栈空等）并给出相应的提示系统信息。
试编程实现该程序。
①输入的形式和输入值的范围：需要用户以键盘输入的方式输入一个正整数序列②输出的形式：通过运行程序后将最后的正整数序列输出。
③程序所能达到的功能：通过对栈的使用完成对正整数序列输出④测试数据：13个元素 1203405607809输出为：13579（二）实现要求：1. 编写函数，实现栈的初始化、入栈、出栈、判断栈空操作。
不限顺序栈或者链栈2. 编写函数，实现正整数序列输出的操作。
3. 编写一个主函数，在主函数中设计一个简单的菜单，分别调试上述算法。
（三）实验指导#include <iostream>using namespace std;#define maxsize 100typedef struct{char str[100];int top;} sqstack;char ch[50];int InitStack(sqstack *S){S->top = -1;return 1;}int Push(sqstack *S,char e){if(S->top>=maxsize-1)return 0;S->top++;S->str[S->top]=e;return 1;}int Pop(sqstack *S,char e){if(S->top<=-1)return 0;S->str[S->top]=S->str[S->top]+1;//S->top--;return 1;}int clear(sqstack *S){S->top=-1;cout<<"栈以清空"<<endl;return 0;}void print(sqstack *S){int i=0;while(i<=S->top)printf("%c",S->str[i++]);printf("\n");}void add(sqstack *S){//InitStack(S);while (ch[i]){switch (ch[i]){case '0' : Pop(S,e);break;default : Push(S,ch[i]);break;}i++;}print(S);}void main(){sqstack *q;int k,n;do{ cout<<"----------------------------------------"<<endl;cout<<"----------------1初始化栈---------------"<<endl;cout<<"----------------2退栈-------------------"<<endl;cout<<"----------------3置空栈-----------------"<<endl;cout<<"----------------4退出程序---------------"<<endl;cout<<"请输入你的选择"<<endl;cin>>k;switch (k){case 1:{q=(sqstack *)malloc(sizeof(sqstack));InitStack(q);print(q);}break;case 2:{cout<<"请输入数据："<<endl;cin>>ch;add(q);}break;case 3:{clear(q);print(q);}break;case 4:exit(4);default : cout<<"选择错误，重新选择"<<endl;}}while(k<=4);}截图：初始化退栈清空栈退出怀化学院计算机系《数据结构》实验报告书题目学生姓名：李月轩学号：1106403009年级专业及班级：计算机系11级IBM班指导老师及职称：高艳霞讲师专业：IBM专业湖南·怀化提交日期：2012年12月10日实验名称：与封面题目一致实验内容：参考实验指导实验目的：参考实验指导实验时间：实验地点：实验题目：参考实验指导，即将其详细题目写出实验过程：#include <iostream>using namespace std;#define maxsize 100typedef structchar str[100];int top;} sqstack;int InitStack(sqstack *S){S->top = -1;return 1;}int Isfull(sqstack *S){if(S->top==100)return 1;elsereturn 0;}int Push(sqstack *S,char e){if(S->top>=maxsize-1)return 0;S->top++;S->str[S->top]=e;return 1;}int Pop(sqstack *S,char e){if(S->top<=-1)return 0;S->str[S->top]=S->str[S->top]+1;//S->top--;return 1;}int clear(sqstack *S)S->top=-1;return 0;}void print(sqstack *S){int i=0;while(i<=S->top)printf("%c",S->str[i++]);printf("\n");}void main(){sqstack *S;char ch,e;S=(sqstack *)malloc(sizeof(sqstack));ch=getchar();InitStack(S);while(!Isfull(S)&&ch!='\n'){while (ch != '\n'){switch (ch){case '0' : Pop(S,e);break;default : Push(S, ch);break;}ch=getchar();}print(S);}}实验测试：实验总结：（100字到200字）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
⏹设计要求
首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。
主控菜单设计要求：程序运行后，显示一个标题“判断表达式括号匹配”，标题下方给出4个菜单项的内容和输入提示：
1．输入表达式
2．输出表达式
3．判断表达式的括号是否匹配并计算表达式的值
4．退出
请选择1—4：
⏹功能要求
完成各菜单的功能，能正确判断表达式的括号匹配（括号限圆括弧和方括弧两种），
若匹配，利用算符优先法计算表达式的值。
计算表达式值的3个相关函数（后面已给出，可以直接粘贴到程序中使用）:
I n(c)---- //判断c是否为运算符
Precede(θ1, θ2) ----//判断两运算符θ1, θ2的优先关系
Operate(a, θ, b)---- //做四则运算a theta b，返回运算结果
⏹实现要求
1)可用VC++的引用或c语言用指针实现各功能的调用
2)必须用栈实现括号匹配和表达式计算
⏹实验提交要求
1)画流程图
2)实现功能的全部程序
3)说明程序设计过程中的难点、解决办法及编程小结或体会。
4)实验及报告必须于2015.4.29提交
Status In(SElemType c) //判断c是否为运算符
{
switch(c)
{
case'+':
case'-':
case'*':
case'/':
case'(':
case')':
case'#':
return TRUE;
default:
return FALSE;
}
}
char Precede(SElemType t1, SElemType t2) //判断两符号的优先关系{
SElemType f;
switch(t2)
{
case'+':
case'-':
if(t1=='('||t1=='#')
f='<';
else
f='>';
break;
case'*':
case'/':
if(t1=='*'||t1=='/'||t1==')')
f='>';
else
f='<';
break;
case'(':
if(t1==')')
{ printf("括号不匹配\n");
exit(OVERFLOW);
}
else
f='<';
break;
case')':
switch(t1)
{
case'(':
f='=';
break;
case'#':
printf("缺乏左括号\n");
exit(OVERFLOW);
default:
f='>';
}
break;
case'#':
switch(t1)
{
case'#':
f='=';
break;
case'(':
printf("缺乏右括号\n");
exit(OVERFLOW);
default:
f='>';
}
}
return f;
}
SElemType Operate(SElemType a,SElemType theta,SElemType b) //做四则运算a theta b，返回运算结果{
SElemType c;
switch(theta)
{
case'+':
return a+b;
case'-':
return a-b;
case'*':
return a*b;
}
return a/b;
}
教师：曹妍2015.4.10。