数据结构实验3后缀表达式求值
数据结构实验报告--表达式求值
void Initstack1(stack1 *s>
{
(*s>->base = (int *>malloc(SIZE * (sizeof(int>>>
。
(*s>->top = (*s>->base
。
(*s>->stacksize = INCREMENT 。
}
int Ifempty2(stack2 *s>
<6）中缀转后缀并计算模块：
( 三 > 详细设计
1．元素类型 , 结点类型和指针类型：
typedef struct{
int stacksize 。 int *base 。
int *top 。
}Sqstack1,*stack1 。
typedef struct{
int stacksize 。
char *base 。
{
if(((a=='*'>||(a=='/'>>&&((b=='+'>||(b=='-'>||(b=='#'>>>
5PCzVD7HxA
return '>'
。
else
return '<'
。
}
<4）运算符操作模块；
int Operate(int a,char b,int c>
{
int t 。
if(b == '+'> t = a + c
{
数据结构实验报告 表达式求值
(一) 需求分析1、输入的形式和输入值的范围：根据题目要求与提示，先选择你要使用的表达式形式（中缀用1，后缀用0），在输入一个中缀表达式，输入数的范围为int型，此时，程序将计算出表达式的结果。
2、输出的形式：当按照程序要求选择了1或0之后，再输入表达式；如果选择的是1，则程序将自动运算出表达式结果；如果之前选择的是0，则程序将现将中缀表达式转化为后缀表达式并计算出结果。
3、程序所能达到的功能：本程序能计算出含+、-、*、/、（、）等运算符的简单运算。
4、测试数据：输入一个表达式，如果你之前选择的是“中缀表达式”，那么输入5*(4-2)#,那么输出结果是10；如果之前选择的是“后缀表达式”，那么输入5*（4-2）#，那么他将先转换成后缀表达式5 4 2 - * #，再输出结果10。
如果输入表达式没有结束标示符#，如5*（4-2），那将不会输出任何结果，或出现错误结果。
(二) 概要设计为了实现上述操作，应以栈为存储结构。
1．基本操作：（1）. int GetTop(SqStack *s)初始条件：栈存在；操作结果：若栈为空，则返回s的栈顶元素；否则返回ERROR。
（2）.void Push(SqStack *s,int e)初始条件：栈存在；操作结果：插入e为新的栈顶元素。
（3）.int Pop(SqStack *s)初始条件：栈存在；操作结果：若栈不空，则删除之，并返回其值；否则返回REEOR。
（4）.void InitStack(SqStack *s)初始条件：栈存在；操作结果：置栈为空。
（5）.int Empty(SqStack *s)初始条件：栈存在；操作结果：判定s是否为空栈。
（6）.int Operate(int a,char theta, int b)初始条件：操作数a和b存在，且theta是+、-、*、/四则运算；操作结果：返回a与b间theta运算的结果。
（7）.int In(char s,char* TestOp)初始条件：s为待判断字符，TestOp为已知的算符集合；操作结果：s为算符集合中的元素则返回1，否则返回0.（8）.int ReturnOpOrd(char op,char* TestOp)初始条件：op为待确定运算符，TestOp为已知的算符集合；操作结果：确定运算符类型。
数据结构表达式求值实验报告
数据结构表达式求值实验报告数据结构表达式求值实验报告第一章引言数据结构是计算机科学中重要的基础知识之一，它研究的是数据在计算机中的存储和组织方式，以及基于这些方式进行操作和运算的算法。
表达式求值是数据结构中一个重要的应用场景，它涉及到从一个给定的表达式中计算出最终结果的过程。
本实验旨在通过实际编程实践，掌握表达式求值的算法和数据结构的应用。
第二章实验目的1.理解表达式的概念。
2.熟悉常见表达式求值算法。
3.掌握栈的基本操作。
4.实现一个表达式求值的程序。
第三章实验内容1.表达式的定义：________表达式是由运算符和运算数组成的字符串，它代表了一种计算规则。
2.表达式的分类：________根据运算符的位置和计算顺序，表达式可以分为前缀表达式、中缀表达式和后缀表达式。
3.表达式求值的算法：________1. 前缀表达式求值算法：________1) 创建一个空栈。
2) 从右往左遍历前缀表达式。
3) 如果当前字符是运算符，则将栈顶的两个元素出栈，进行相应的运算，将结果入栈。
4) 如果当前字符是运算数，则将其转化为整数形式，并入栈。
5) 最终栈内只剩下一个元素，即为表达式的求值结果。
2. 中缀表达式求值算法：________1) 将中缀表达式转化为后缀表达式。
2) 创建一个空栈。
3) 从左往右遍历后缀表达式。
4) 如果当前字符是运算符，则将栈顶的两个元素出栈，进行相应的运算，将结果入栈。
5) 如果当前字符是运算数，则将其转化为整数形式，并入栈。
6) 最终栈内只剩下一个元素，即为表达式的求值结果。
3. 后缀表达式求值算法：________1) 创建一个空栈。
2) 从左往右遍历后缀表达式。
3) 如果当前字符是运算符，则将栈顶的两个元素出栈，进行相应的运算，将结果入栈。
4) 如果当前字符是运算数，则将其转化为整数形式，并入栈。
5) 最终栈内只剩下一个元素，即为表达式的求值结果。
4.实验代码实现：________根据算法描述，使用编程语言实现一个表达式求值的程序。
数据结构 后缀表达式的计算
深圳大学实验报告课程名称：数据结构实验名称：后缀表达式的计算班级： 1 姓名：同组人：无实验日期：2011 年10 月11 日教师签字：一、实验目的熟悉栈的使用。
掌握如何使用C语言实现栈的说明、创建以及进栈和出栈等操作。
二、实验要求熟悉C语言编程。
三、实验内容编写单独的初始化栈、判空、入栈和出栈以及取得栈顶元素的函数编写compute()函数，实现后缀表达式的计算，在该函数中对第一步实现的栈函数进行调用以完成计算四、实验步骤（算法）实现后缀表达式423*+42/-#的运算1.依次读入数字和运算符当读入的是数字时进栈，当读入的是运算符时出栈两次并把两个出栈的数据进行运算符所实现的运算，一直这样的操作直到所读的数据为#时，输出栈底元素即为所要计算的结果。
五、程序代码#include <iostream.h>#define error 0#define ok 1#define TRUE 1#define FALSE 0#define STACK_INIT_SIZE 100 #define OVERFLOW -2#define STACKINCREMENT 10 #include <string.h>typedef int elemtype;#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct{elemtype *base;elemtype *top;int stacksize;}bds_stack;int pop(bds_stack &S,int &e){if(S.top==S.base) return error;e= * --S.top;return ok;}int InitStack (bds_stack &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;}int GetTop(bds_stack S,elemtype&e){if(S.top==S.base) return error;return e=*(S.top-1);}//GetTopint push(bds_stack &S,int 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;}int compute (char A[], int &k){int i=0;int x1,x2,temp, e;bds_stack bds; //定义一个栈InitStack (bds); //初始化栈while (A[i]!='#') //依次取得后缀表达式中的字符判断并操作{if (('0'<=A[i])&&(A[i]<='9') )push(bds,A[i]-'0'); //如果是操作数，压栈else{//如果是操作符pop(bds,x2); //操作数2，出栈pop(bds,x1); //操作数1，出栈//计算switch (A[i]){case '+':temp=x1+x2;break;case '-': temp=x1-x2;break;case '*': temp=x1*x2;break;case '/':temp=x1/x2;break;}push(bds,temp); //计算结果压栈}i++; //指针后移}GetTop(bds,e);return k=e;}int StackEmpty(bds_stack s){if(s.top==s.base)return TRUE;elsereturn FALSE;}void main(){char bds_hz[]="423*+42/-#";//后缀表达式int j;compute (bds_hz,j);cout<<j<<endl; //输出表达式结果}六、实验结果（屏幕截图）七、心得体会本次实验的要求有多个，但我只做了其中的一小部分，为后缀表达式的求值。
数据结构表达式求值实验报告-无删减范文
数据结构表达式求值实验报告数据结构表达式求值实验报告1. 引言表达式求值是计算机科学中的一个重要问题，也是数据结构的一个经典应用。
通过将中缀表达式转换为后缀表达式，并利用栈这一数据结构，可以实现对表达式的有效求值。
本实验旨在探究数据结构在表达式求值中的应用。
2. 实验内容本实验中，我们将实现一个表达式求值的程序。
具体步骤如下：1. 将中缀表达式转换为后缀表达式。
2. 使用栈来求解后缀表达式。
3. 算法原理3.1 中缀表达式转后缀表达式中缀表达式是我们常见的数学表达式，如 2 + 3 4。
而后缀表达式是将操作符放在操作数后面的表达式，上述中缀表达式的后缀表达式为 2 3 4 +。
中缀表达式到后缀表达式的转换可以通过以下步骤完成：1. 初始化一个栈和一个输出队列。
2. 从左到右遍历中缀表达式的每个字符。
3. 如果当前字符是数字，将其加入输出队列。
4. 如果当前字符是左括号，将其压入栈。
5. 如果当前字符是右括号，将栈中的操作符依次弹出并加入输出队列，直到遇到左括号为止。
6. 如果当前字符是操作符，将其与栈顶操作符进行比较：1. 如果栈为空，或者栈顶操作符为左括号，直接将当前操作符压入栈。
2. 否则，比较当前操作符与栈顶操作符的优先级，如果当前操作符的优先级较低，将栈顶操作符弹出并加入输出队列，然后将当前操作符压入栈。
3. 如果当前操作符的优先级大于等于栈顶操作符的优先级，则直接将当前操作符压入栈。
7. 遍历完中缀表达式后，将栈中的操作符依次弹出并加入输出队列。
3.2 后缀表达式求值通过将中缀表达式转换为后缀表达式，我们可以利用栈来对后缀表达式进行求值。
具体求值操作如下：1. 初始化一个栈。
2. 从左到右遍历后缀表达式的每个字符。
3. 如果当前字符是数字，将其加入栈。
4. 如果当前字符是操作符，从栈中弹出两个数字，进行相应的运算，然后将结果加入栈。
5. 遍历完后缀表达式后，栈中的元素即为最终的结果。
4. 实验结果我们用中缀表达式\。
中缀表达式转换成后缀表达式
实验三中缀表达式转换成后缀表达式，然后按后缀表达式计算实验一、实验目的：对所学数据结构知识进行温习，比如栈和队列的顺序存储结构和链式结构、大体操作进行温习；将一个中缀表达式转换成后缀表达式，然后按后缀表达式计算进行分析与设计，上机调试，最终达到应用的目。
二、实验要求：要求对中缀表达式转换成后缀表达式，然后按后缀表达式计算作设计性实验，并上机运行，撰写实验报告。
三、实验内容：将一个中缀表达式转换成后缀表达式，然后按后缀表达式计算，例如：5+(4+2)/2-3*2。
四、实验环境：Windows XP + VC++6.0开发环境。
五、上机调试代码：# include<stdio.h># include<stdlib.h>typedef char typedata1;typedef int typedata2;typedef struct charnode{typedata1 data;struct charnode *next;}charstack;typedef struct intnode{typedata2 data;struct intnode *next;}intstack;char s[100];charstack *creat(){ charstack *head;head=(charstack *)malloc(sizeof(charstack));head->data='#';head->next=0;return head;}intstack *intcreat(){ intstack *head;head=(intstack *)malloc(sizeof(intstack));head->data=0;head->next=0;return head;}charstack *push(charstack *top,char x){charstack *p;p=(charstack *)malloc(sizeof(charstack));p->data=x;p->next=top;top=p;return top;}intstack *intpush(intstack *top,int x){intstack *p;p=(intstack *)malloc(sizeof(intstack));p->data=x;p->next=top;top=p;return top;}typedata1 top(charstack *top){return top->data;}typedata2 inttop(intstack *top){return top->data;}char compare(char x1,char x2){char m;int m1,m2;if(x1=='+'||x1=='-') m1=0;else if(x1=='*'||x1=='/') m1=1;else if(x1=='(') m1=2;if(x2=='+'||x2=='-') m2=0;else if(x2=='*'||x2=='/') m2=1;else if(x2=='(') m2=2;if(m1>m2) m='>';else if(m1<m2) m='<';else m='=';return m;}charstack *popl(charstack *top){ charstack *p;if(top==0)printf("下溢!");else{p=top;top=top->next;free(p);return top;}}intstack *intpopl(intstack *top){ intstack *p;if(top==0)printf("下溢!");else{p=top;top=top->next;free(p);return top;}}void display(char m[],int n){int i;for(i=0;i<=n;i++)printf("%c",m[i]);}int change(char a[],int n){int i;int j=0;char x1,x2,bj;charstack *q;q=creat();for(i=0;i<n;i++){if(a[i]<='9'&&a[i]>='0'){s[j]=a[i];j=j+1;if(a[i+1]>'9'||a[i+1]<'0'){s[j]=' ';j=j+1;}}else{x1=a[i];x2=top(q);if(x2=='#')q=push(q,x1);else{if(x1==')'){while(top(q)!='('){s[j]=top(q);j=j+1;q=popl(q);}q=popl(q);}else{bijiao:bj=compare(x1,x2);switch(bj){case '>':q=push(q,x1);break;case '<':if(x2!='('){s[j]=top(q);j=j+1;q=popl(q);x2=top(q);if(x2!='#') goto bijiao; else q=push(q,x1);break;}else q=push(q,x1);break;case '=':s[j]=top(q);j=j+1;q=popl(q);q=push(q,x1);break;}}}}}while(top(q)!='#'){s[j]=top(q);j=j+1;q=popl(q);}return j;}int calculator(char s[],int n){int i,x1,x2,x;intstack *q;q=intcreat();for(i=0;i<=n;i++){if(s[i]==' ') i=i+1;if(s[i]<='9'&&s[i]>='0'){x1=(int)s[i]-48; while(s[i+1]<='9'&&s[i+1]>='0'){x1=10*x1+(int)s[i+1]-48;i=i+1;}q=intpush(q,x1); }else if(s[i]=='+'){ x2=inttop(q);q=intpopl(q);x1=inttop(q);q=intpopl(q);q=intpush(q,x1+x2); }else if(s[i]=='-'){ x2=inttop(q);q=intpopl(q);x1=inttop(q);q=intpopl(q);q=intpush(q,x1-x2); }else if(s[i]=='*'){ x2=inttop(q);q=intpopl(q);x1=inttop(q);q=intpopl(q);q=intpush(q,x1*x2); }else if(s[i]=='/'){ x2=inttop(q);q=intpopl(q);x1=inttop(q);q=intpopl(q);q=intpush(q,x1/x2);}}x=inttop(q);return x;}void main(){int i,k;char f[100];printf("请输入中缀表达式(输入#终止)：\n");for(i=0;i<100;i++){scanf("%c",&f[i]);if(f[i]=='#')break;}printf("\n后缀表达式为：");k=change(f,i);display(s,k);printf("\n\n计算结果为：%d\n\n",calculator(s,k)); }六、实验结果分析：1）实验运行结果及测试截图如下：2）本实验对字符也一样能得出后缀表达式，可是没有赋具体值，故不能算结果，同时呢也会弹出运用程序错误提示，测试截图如下：3）实验改良，若是本实验能在改良为，当输入为字符时自动提示为此字符赋值，那么此程序也将能计算出带有字符的的表达式的结果,同时本实验也能够通过其它算法实现。
表达式求值数据结构实训报告
数据结构实训总结报告题目：表达式求值学生姓名：学生学号：专业班级：指导老师：目录1.课题分析 .....................................................................1．1需求分析..............................................................1. 2设计要求............................................................2.总体设计.......................................................................2．1主程序的流程.....................................................3.详细设计（步骤及代码实现） ...................................3. 1判断运算符优先级..............................................3. 2中缀表达式转后缀表达式..................................3. 3后缀表达式求值.................................................. 4．测试结果 .................................................................... 5．心得体会 .................................................................... 6．参考文献 ....................................................................1.课题分析1．1需求分析（1）栈“后进先出”的特点。
数据结构实验3后缀表达式求值
int top;
}opstack;
typedef struct
{ float data[Maxle n];
int top;
}stack;
void tran s(char str[],char exp[]) //求后缀表达式
{ opstack op;
char ch;
default:
while(ch>='0' && ch<='9')
{ exp[t]=ch;
t++;
ch=str[i#39;';
t++;
ch=str[i];
i++;
}
while(op.top!=-1)
{ exp[t]=op.data[op.top];
t++;
op.top--;
break;
case'*':
case'/':
while(op.top=='/'||op.top=='*')
{ exp[t]=op.data[op.top];
op.top--;
t++；
}
op.top++;
op.data[op.top]=ch;
break;
case' '://输入为空格，则跳过
break;
-2 -
op.top=-1;
ch=str[i];
i++；
while(ch!='\O')
实验报告后缀式计算
一、实验目的1. 了解后缀式（逆波兰表示法）的概念和特点。
2. 掌握后缀式计算器的实现方法。
3. 通过实验，提高对后缀式计算器原理的理解和应用能力。
二、实验原理后缀式，又称逆波兰表示法，是一种将运算符放在操作数之后的数学表达式表示方法。
在这种表示法中，运算符的操作顺序和括号的使用规则与常规表示法不同。
后缀式计算器可以实现直接对后缀式进行计算，而不需要考虑运算符的优先级和括号的使用。
后缀式计算器的实现原理如下：1. 初始化一个空栈，用于存储操作数和运算符。
2. 从左到右遍历后缀式中的每个字符：a. 如果是操作数，则将其压入栈中。
b. 如果是运算符，则从栈中弹出两个操作数，进行运算，并将运算结果压入栈中。
3. 遍历完成后，栈中的元素即为后缀式的计算结果。
三、实验步骤1. 设计后缀式计算器程序。
2. 编写程序实现后缀式的计算。
3. 对程序进行测试，验证其正确性。
四、实验内容及结果1. 设计后缀式计算器程序```pythondef calculate_postfix(expression):stack = []operators = {'+': lambda x, y: x + y,'-': lambda x, y: x - y,'': lambda x, y: x y,'/': lambda x, y: x / y}for char in expression:if char.isdigit():stack.append(int(char))elif char in operators:operand2 = stack.pop()operand1 = stack.pop()result = operators[char](operand1, operand2)stack.append(result)return stack[-1]# 测试expression = "3 4 + 2 7 /"result = calculate_postfix(expression)print("计算结果为：", result)```2. 编写程序实现后缀式的计算在上述程序中，我们实现了后缀式计算器的核心功能。
数据结构实验报告-3-求解算术表达式
实验3 利用栈实现算术表达式求值一、实验目的1、帮助读者复习C语言程序设计中的知识。
2、熟悉栈的逻辑结构。
3、了解算术表达式计算的逻辑过程。
4、熟悉算术表达式计算过程中优先级的运算方法。
5、了解中缀表达式和后缀表达式的区别。
二、实验内容[问题描述]1.实验目标：利用栈的特性，实现算术表达式的运算，了解算术运算的逻辑，掌握栈的特性。
2.中缀表达式与后缀表达式的含义中缀表达式就是通常所说的算术表达式，比如(1+2)*3-4。
后缀表达式是指通过解析后，运算符在运算数之后的表达式，比如上式解析成后缀表达式就是12+3*4-。
这种表达式可以直接利用栈来求解。
[基本要求]（1）利用栈实现后缀表达式的计算；（2）利用栈实现中缀表达式到后缀表达式的转换。
（可选）基于程序易于设计的考虑，我们仅需要实现一位数值（0-9）的+，-，*，/，()等运算。
三、设计思路四、源代码#include<stdio.h>#include<string.h>#include<stdlib.h>#define max 100typedef struct{float data[max];int top;}seqstack;void InitStack(seqstack *s);int StackEmpty(seqstack *s);int StackFull(seqstack *s);void Push(seqstack *s,char x);int Pop(seqstack *s);float ComputeExpress(char a[]);void main(){char a[max],b[max];float f;printf("请输入一个后缀表达式:\n");gets(a);printf("后缀表达式为:%s\n",a);f=ComputeExpress(b);printf("计算结果为:%f\n",f);}void InitStack(seqstack *s){s->top=-1;}int StackEmpty(seqstack *s){return s->top==-1;}int StackFull(seqstack *s){return s->top==max-1;}void Push(seqstack *s,char x){if(StackFull(s))printf("overflow");s->data[++s->top]=x;}int Pop(seqstack *s){if(StackEmpty(s))printf("underflow");return s->data[s->top--];}float ComputeExpress(char a[]){seqstack s;int i=0;float x1,x2,value;float result;s.top=-1;while(a[i]!='\0'){if(a[i]!=' '&&a[i]>='0'&&a[i]<='9'){value=0;while(a[i]!=' '){value=10*value+a[i]-'0';i++;}s.top++;s.data[s.top]=value;}else{switch(a[i]){case'+':x1=s.data[s.top];s.top--;x2=s.data[s.top];s.top--;result=x1+x2;s.top++;s.data[s.top]=result;break;case'-':x1=s.data[s.top];s.top--;x2=s.data[s.top];s.top--;result=x2-x1;s.top++;s.data[s.top]=result;break;case'*':x1=s.data[s.top];s.top--;x2=s.data[s.top];s.top--;result=x1*x2;s.top++;s.data[s.top]=result;break;case'/':x1=s.data[s.top];s.top--;x2=s.data[s.top];s.top--;result=x2/x1;s.top++;s.data[s.top]=result;break;}i++;}}if(s.top!=-1)result=s.data[s.top];s.top--;if(s.top==-1)return result;else{printf("表达式错误");exit(-1);}}五、测试结果六、心得体会这次实验我只做了利用栈实现后缀表达式的计算熟悉栈的逻辑结构，同时了解算术表达式计算的逻辑过程。
表达式求值 实验报告
表达式求值实验报告表达式求值实验报告一、引言表达式求值是计算机科学中一个重要的概念，它涉及到对数学表达式的计算和求解。
在本次实验中，我们将探讨表达式求值的相关算法和实现方法，并通过编程实现一个简单的表达式求值器。
二、算法原理1. 表达式的表示方法在计算机中，我们通常使用字符串来表示表达式。
例如，一个简单的数学表达式"2 + 3 * 4"可以表示为字符串"2+3*4"。
在实现表达式求值的算法时，我们需要将字符串中的数字和运算符进行分离，以便进行后续的计算。
2. 中缀表达式转后缀表达式为了方便计算，我们通常将中缀表达式转换为后缀表达式。
后缀表达式也称为逆波兰表达式，它的特点是运算符位于操作数的后面。
例如，上述的中缀表达式"2+3*4"可以转换为后缀表达式"234*+"。
转换的方法可以通过使用栈来实现。
3. 后缀表达式求值得到后缀表达式后，我们可以通过扫描表达式并使用栈来求解。
当遇到操作数时，将其压入栈中；当遇到运算符时，从栈中弹出相应数量的操作数进行计算，并将结果压入栈中。
最终，栈中的唯一元素即为表达式的求值结果。
三、实验过程1. 数据结构设计为了实现表达式求值器，我们需要设计相应的数据结构。
在本次实验中，我们选择使用栈来存储操作数和运算符。
2. 中缀表达式转后缀表达式首先，我们需要编写一个函数来将中缀表达式转换为后缀表达式。
该函数的实现可以通过使用栈和遍历字符串来实现。
具体的步骤如下：- 创建一个空栈和一个空字符串用于存储后缀表达式。
- 从左到右遍历中缀表达式的每个字符。
- 如果遇到操作数，直接将其添加到后缀表达式字符串中。
- 如果遇到运算符，将其与栈顶的运算符进行比较：- 如果栈为空或栈顶为左括号"("，则直接将运算符入栈。
- 如果栈顶的运算符优先级低于当前运算符，则将当前运算符入栈。
- 如果栈顶的运算符优先级高于或等于当前运算符，则将栈顶的运算符弹出并添加到后缀表达式字符串中，直到栈顶的运算符优先级低于当前运算符或栈为空。
数据结构表达式求值实验报告
数据结构表达式求值实验报告一、实验目的本次实验的主要目的是通过实现表达式求值的程序，深入理解数据结构和算法在解决实际问题中的应用。
具体包括掌握栈这种数据结构的操作和使用，熟悉表达式的转换和计算过程，提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理表达式求值是程序设计中的一个常见问题，通常采用栈这种数据结构来实现。
表达式可以分为中缀表达式、后缀表达式和前缀表达式。
中缀表达式是我们日常使用的表达式形式，如“2 ＋3 4”，但直接对中缀表达式求值比较复杂。
而后缀表达式（如“2 3 4 ＋”）和前缀表达式（如“＋2 3 4”）求值相对简单。
因此，在实现表达式求值时，通常先将中缀表达式转换为后缀表达式，然后对后缀表达式进行求值。
转换过程中，使用两个栈，一个用于存储操作数，另一个用于存储运算符。
求值过程中，根据后缀表达式的特点，从左到右依次处理操作数和运算符，进行相应的计算。
四、实验步骤1、定义数据结构定义栈类，用于存储操作数和运算符。
定义一个结构体来表示操作数和运算符。
2、中缀表达式转后缀表达式从左到右扫描中缀表达式。
遇到操作数，直接输出。
遇到运算符，根据其优先级与栈顶运算符的优先级进行比较，决定入栈或出栈操作。
3、后缀表达式求值从左到右扫描后缀表达式。
遇到操作数，入栈。
遇到运算符，从栈中取出两个操作数进行计算，将结果入栈。
4、主函数输入中缀表达式。
调用转换函数和求值函数，输出计算结果。
五、实验代码｀｀｀cppinclude ＜iostream>include ＜stack>include ＜string>／／定义操作符的优先级int priority(char op) ｛if （op ＝＝＇＋＇｜｜ op ＝＝＇＇）return 1;if （op ＝＝＇＇｜｜ op ＝＝＇／＇）return 2;return 0;｝／／中缀表达式转后缀表达式std:：string infixToPostfix(std:：string infix) ｛std:：stack<char> opStack;std:：string postfix ＝＂＂；for （char c ： infix) ｛if （isdigit(c)）｛postfix ＋＝ c;｝ else if （c ＝＝＇（＇）｛｝ else if （c ＝＝＇）＇）｛while （！opStackempty(）＆＆ opStacktop(）！＝＇（＇）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpop(）；／／弹出＇（＇｝ else ｛while （！opStackempty(）＆＆ priority(opStacktop(））＞＝priority(c)）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpush(c)；｝｝while （！opStackempty(））｛postfix ＋＝ opStacktop(）；｝return postfix;｝／／后缀表达式求值int evaluatePostfix(std:：string postfix) ｛std:：stack<int> operandStack;for （char c ： postfix) ｛if （isdigit(c)）｛operandStackpush(c ＇0'）；｝ else ｛int operand2 ＝ operandStacktop(）；operandStackpop(）；int operand1 ＝ operandStacktop(）；operandStackpop(）；switch （c) ｛case ＇＋＇：operandStackpush(operand1 ＋ operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇／＇：operandStackpush(operand1 ／ operand2)；break;｝｝｝return operandStacktop(）；｝int main(）｛std:：string infixExpression;std:：cout ＜＜＂请输入中缀表达式: ＂；std:：cin ＞＞ infixExpression;std:：string postfixExpression ＝ infixToPostfix(infixExpression)；int result ＝ evaluatePostfix(postfixExpression)；std:：cout ＜＜＂表达式的计算结果为: ＂＜＜ result ＜＜ std:：endl;return 0;｝｀｀｀六、实验结果输入不同的中缀表达式，如“2 ＋3 4”“（ 2 ＋ 3 ）4”等，程序能够正确地将其转换为后缀表达式，并计算出结果。
后缀算术表达式求值
实验名称：后缀算术表达式求值背景描述：表达式求值是程序设计语言编译中的一个最基本的问题。
因为任何程序设计语言都必须具有表达式求值的功能，同时表达式的计算应用也相当广泛，比如电力调度系统中的计算遥测、车站票务系统中的票价类型计算公式等。
通常，我们所说的表达式是由运算符、操作数、界限符所组成。
而算术表达式中最常见的表示法形式有中缀、前缀和后缀表示法。
中缀表示法是书写表达式的常见方式，而前缀和后缀表示法主要用于计算机科学领域。
一、表达式表示法1、中缀表达式---将运算符放在两操作数的中间。
在运算中存在运算符的优先权与结合性的问题。
例如运算：a*b+(c-d/e)*f 时，编译器即自左向右逐一检查，当检查到第一个运算符"*"时还无法知道是否执行；待检查到第二个运算符" + "时，因为知道"*"的优先级别高于" + "时，才知道执行"a*b"；当继续检查到" ( "时，可知道先执行括号以内部分等。
2、前缀表达式---将运算符放在两操作数的前面。
这种表示法经常用于计算机科学，特别是编译器设计方面。
为纪念其发明家-Jan Lukasiewicz，这种表示法也称波兰表示法。
3、后缀表达式---将运算符放在两操作数的后面。
后缀表达式也称逆波兰表达式，因其使表达式求值变得轻松，所以被普遍使用。
前缀和后缀表示法有三项公共特征：（1）操作数的顺序与等价的中缀表达式中操作数的顺序一致；（2）不需要括号；（3）操作符的优先级不相关。
问题描述：读入一个后缀表达式表达式，利用堆栈来计算该表达式的值，同时要效验后缀表达式是否正确。
输入输出格式：第一种方式：输入：在字符界面上输入一个后缀表达式，其中两相邻操作数之间利用空格隔开。
以"#"表示结束。
输出：如果该后缀表达式正确，那么在字符界面上输出其结果，计算结果小数点后面保留两位有效数字，如果不正确，请在字符界面上输出表达式错误提示。
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一：数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院：化学与材料科学学院专业班级：09级材料科学与工程系pb0920603姓学邮名：李维谷号：pb09206285箱：指导教师：贾伯琪实验时间：20XX年10月10日一、需要分析问题描述：表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。
设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时，借助栈实现。
设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。
算法规定：输入形式：一个(:数据结构表达式求值实验报告)算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。
为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。
输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。
程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。
测试数据：正确输入：12*（3.6/3+4^2-1）#输出结果：194.4无定义运算：12*（3.6/（2^2-4）+1）#输出结果：表达式出错，除数为0，无意义错误输入：12+s#输出结果：eRRoR！二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
数据结构实验报告三-逆波兰表达式
数据结构实验报告三-逆波兰表达式问题描述：读入一个后缀表达式，利用堆栈来计算该表达式的值，同时要效验后缀表达式是否正确。
一、需求分析：1、用户从界面输入一个后缀表达式，用字符数组存储，以回车间结束2、若表达式正确，界面自动输出后缀表达式的值，否则输出表达式错误的信息，将结果置为0。
3测试数据：输入：请输入一个后缀表达式：2 3 * 1 –输出：该表达式的值：5二、概要设计：抽象数据类型由于操作的事一串字符，所以首先选择一个字符数组存储该串字符，直接使用编译器自带的字符数组。
算法的基本思想由于计算后缀表达式时，具有先进后出的规律，故而考虑使用堆栈其ADT Stack{操作对象：字符，整数，浮点数基本操作：Stack(int size);//构造大小为size的堆栈~Stack()；//撤销堆栈Bool IsEmpty();//是否为空，是返回true，否则返回falseBool IsFull();//是否为满，是返回true，否则返回falseVoid Push(T X);//将x压入堆栈Void Pop(T &x);//弹出栈顶元素，并用x保存对于计算后缀表达式的值的算法：首先假设此表达式正确从字符串第一个开始扫描，遇到运算数就先转化成为数值然后压入堆栈中，如遇到运算符则弹出堆栈上面的两个元素，并进行对应的运算，将得到的值压入栈中，直到最后一个字符为止。
对于表达式错误：返回0程序的流程程序由三个模块组成：输入模块：输入一个后缀表达式：2 3 * 1 –计算模块：计算出后缀表达式的值输出模块：输出表达式的值：5三、详细设计算法的具体步骤：对于ADT Stack模板:物理数据类型采用数组：#includeusing namespace std;const int MaxSize=1000;templateclass Stack{public:Stack(int size=0); //构造大小为size的堆栈~Stack(){delete p;} //撤销堆栈bool IsFull(){return top==Size;} //判断堆栈是否已满bool IsEmpty(){return top==0;} //判断堆栈是否为空void Push(T &x); //将x压入堆栈T Pop(T &x); //将栈顶元素弹出用x保存private:int Size;//大小int top;//栈顶T *p;//数组指针};//构造堆栈templateStack::Stack(int size){Size=size;//栈大小为sizetop=0;//栈顶top指向0p=new T[Size];//为p开辟Size大小的空间}//向堆栈中压入xtemplatevoid Stack::Push(T &x){p[top++]=x;//将x保存于栈顶，栈顶+1}//弹出栈顶元素templateT Stack::Pop(T &x){x=p[--top];//x保存栈顶元素，栈顶-1return x;}/*上述每个函数时间复杂度O(1);对于后缀表达式求值函数*/float nibolan (char *array){ //array存储表达式Stack sta(MaxSize); //建立大小为Maxsize的堆栈int i=0;if(array[0]=='.'){cout<<"表达式错误:小数表示错误"<<endl;< p="">return 0;}while(array[i]!='\0'){ //当表达式没有结束if(array[i]=='.'){//数字第一个字符为小数点或运算符后是小数点cout<<"表达式错误:小数表示错误"<<endl;< p="">return 0;}if(i==0&&array[i]=='-'){//判断第一个是否负数，后面的没有必要判断，如果是i++; //处理下一个字符float tem=0;while(array[i]>='0'&&array[i]<='9'){tem=(float)array[i]-48+tem*10;//先计算该负数的绝对值i++;}if(array[i]=='.'){//若存在小数i++;//忽略该位if(!(array[i]>='0'&&array[i]<='9')){//小数点后不是数字cout<<"表达式错误:小数表示错误"<<endl;< p="">return 0;}}Stack s(7);//用于存储小数字符while(array[i]>='0'&&array[i]<='9'){s.Push(array[i]);i++;}float item=0;char x;while(!s.IsEmpty())item=((float)s.Pop(x)-48)*0.1+item*0.1;//计算小数tem+=item;tem=-tem;//取相反数得到原数sta.Push(tem);//将该数压入栈中}if(array[i]>='0'&&array[i]<='9'){//其他时候，判断是否为数字float tem=0;while(array[i]>='0'&&array[i]<='9'){//计算整数部分tem=(float)array[i]-48+tem*10;i++;}if(array[i]=='.'){//若存在小数i++;//忽略该位if(!(array[i]>='0'&&array[i]<='9')){//小数点后不是数字cout<<"表达式错误:小数表示错误"<<endl;< p="">return 0;}}Stack s(7);//用于存储小数字符while(array[i]>='0'&&array[i]<='9'){s.Push(array[i]);i++;}float item=0;char x;while(!s.IsEmpty())item=((float)s.Pop(x)-48)*0.1+item*0.1;//计算小数tem+=item;sta.Push(tem);}if(array[i]=='+'||array[i]=='-'||array[i]=='*'||array[i]=='/'){ float it1,it21,it22;//it21栈顶元素，it22倒数第二个，it1是it21，it22对应运算的值char ch=array[i];switch(ch){case '+':it21=sta.Pop(it21);if(sta.IsEmpty()){cout<<"表达是错误:运算符比对应所需的运算数多"<<="">return 0;}it22=sta.Pop(it22);it1=it21+it22;sta.Push(it1);break;case '-':it21=sta.Pop(it21);if(sta.IsEmpty()){cout<<"表达是错误:运算符比对应所需的运算数多"<<endl;< p="">return 0;}it22=sta.Pop(it22);it1=it22-it21;sta.Push(it1);break;case '*':it21=sta.Pop(it21);if(sta.IsEmpty()){cout<<"表达是错误:运算符比对应所需的运算数多"<<endl;< p="">return 0;}it22=sta.Pop(it22);it1=it21*it22;sta.Push(it1);break;case '/':it21=sta.Pop(it21);if(sta.IsEmpty()){cout<<"表达是错误:运算符比对应所需的运算数多"<<endl;< p="">return 0;}it22=sta.Pop(it22);it1=it22/it21;sta.Push(it1);break;default:break;}i++;}elsei++;}float value;sta.Pop(value);if(!sta.IsEmpty()){cout<<"表达式错误:运算数多于所需的运算符"<<="">return 0;}return value;}时间复杂度：该算法的时间复杂度O(n);四、调试分析略。
湖南大学数据结构试验3四则运算表达式求值
实验四四则运算表达式的求值一、需求分析1. 要求对四则运算表达式求值，将四则运算表达式用中缀表达式表示，然后转换为后缀表达式，并计算结果。
利用二叉树来实现要求，注意浮点数和整形数的转换。
利用二叉树后续遍历来实现表达式的转换，同时可以使用实验2的结果来求解后缀表达式的值。
2.中缀表达式由键盘输入（输入的字符串长度小于100），对非法表达式做错误判断和说明在Dos界面输出出列的项3.测试数据输入：21+23*（12-6）输出：21 23 12 6 -*+result is 159.00二、概要设计1．输入中缀表达式转换后缀表达式，以及计算出的结果ADT LinkList {数据对象：D是具有相同特性的数据元素的集合。
数据关系：若D为空寂，则称为空树；（1）.若D仅含有一个数据元素，则R为空集，否则R={H}，H是如下二元关系：在D中仅存在为一的称为根的数据元素root，它在关系H下无前驱；（2）.若D-{root}的一个划分D1，D2，…Dm（m>0），对任意j不等于k（1<=j,k<=m）有Dj和Dk的交集为空，且任意的i（1<=i<=m）,唯一存在数据元素Xi属于Di，有<root,Xi>属于H；（3）.对应于D-{root}的划分，H-{<root,Xi>,…,<root,Xm>}有唯一的一个划分H1,H2，…Hm（m>0），对任意j不等于k（1<=j,k<=m）有Hj和Hk的交集为空，且对任意i（1<=i<=m），Hi是Di上的二元关系，（Di，{Hi}）是一棵符合定义的树，称为根root的子树。
基本操作：int CrtNode(stack <BiTree> &PTR, char *c)操作结果：创建二叉树的根节点，并把值保存在根节点。
void CrtSubTree(stack <BiTree> &PTR, char c)初始条件：二叉树根节点存在操作结果：建立二叉树的子树void CrtExptree(BiTree &T, char exp[])初始条件：二叉树存在操作结果：根据字符串exp的内容构建表达式树Tvoid PostOrderTraverse(BiTree &T, char * exp ,int &count)初始条件：二叉树不为空操作结果：后序遍历二叉树，依据T->len的值，把T->data中的字符依次添加到当前exp字符串的尾端} ADT LinkList2．本程序包含三个基本模块（1）主程序模块：其中又包括构建二叉树和后序遍历二叉树及计算后序表达式的值（2）线性表模块：实现线性表的抽象数据类型（3）元素结构单元模块：定义线性表每个元素的结构三、详细设计1．元素类型，二叉树类型typedef struct BiTNode {TElemType data;int len; //data字符串中字符的个数struct BiTNode * lchild, * rchild;}BiTNode, *BiTree;栈类型：c++标准容器stack容器2．根据二叉树和栈的特点，T即为该二叉树的名称，该程序的基本操作具体实二叉树T—>后序遍历二叉树—>计算二叉树的后序表达式的值—>删除中间指针—>结束3．主程序中：四、调试分析1．输入“4**”诸如此类的表达式时，程序运行时不会报出错误，因为该程序不能判别一些不合法公式的输入情况，类似的情况太多，着重点不在这些错误上。
实用数据结构基础实验3：后缀表达式求值
实用数据结构基础（第二版）实验3：后缀表达式求值让人想念而死，是谋杀的至高境界，就连法医也鉴定不出死因。
#include<>#include<>struct node // 栈结构声明{int data; // 数据域struct node *next; // 指针域};typedef struct node stacklist; // 链表类型typedef stacklist *link; // 链表指针类型link operand=NULL; // 操作数栈指针link push(link stack,int value) // 进栈{link newnode; // 新结点指针newnode=new stacklist; // 分配新结点if (!newnode){printf("分配失败！");return NULL;}newnode->data=value; // 创建结点的内容newnode->next=stack;stack=newnode; // 新结点成为栈的开始return stack;}link pop(link stack,int *value) // 出栈{link top; // 指向栈顶if (stack !=NULL){top=stack; // 指向栈顶stack=stack->next; // 移动栈顶指针 *value=top->data; // 取数据 delete top; // 吸收结点return stack; // 返回栈顶指针 }else*value=-1;}int empty(link stack) // 判栈空{if (stack!=NULL)return 1;elsereturn 0;}int isoperator(char op) // 判运算符{switch (op){case'+':case'-':case'*':return 1; // 是运算符,返回1case'/':return 0; // 不是运算符,返回0}}int getvalue(int op,int operand1,int operand2) // 计算表达式值{switch((char)op){case'*':return(operand1*operand2);case'/':return(operand1/operand2);case'+':return(operand1+operand2);case'-':return(operand1-operand2);}}void main() // 主函数{char exp[100];int operand1=0; // 定义操作数1int operand2=0; // 定义操作数2 int result=0; // 定义操作结果int pos=0;printf("\t\n 请输入后缀表达式：");gets(exp); // 读取表达式printf("\t\n\n 后缀表达式[%s]的计算结果是：",exp);while (exp[pos] !='\0' && exp[pos] !='\n') // 分析表达式字符串{if (isoperator(exp[pos])) // 是运算符，取两个操作数{operand=pop(operand,&operand1);operand=pop(operand,&operand2);operand=push(operand,getvalue(exp[pos],operand1,operand2));// 计算结果入栈}elseoperand=push(operand,exp[pos]-48); // 是操作数，压入操作数栈 pos++; // 移到下一个字符串位置}operand=pop(operand,&result); // 弹出结果printf("%d\n",result); // 输出}。
后缀表达式求值
数据结构实验报告知识范畴：栈与队列完成日期：2017年4月03日实验题目：后缀表达式求值实验内容及要求：从键盘输入后缀表达式（运算符和操作数建议以字符串形式输入，空格作为分隔符），计算并输出后缀表达式的求值结果。
基本要求：实现 +, -, *, /四个二元运算符；实现+, -两个一元运算符（即正、负号）；操作数用整数表示。
提高要求：输出对应的前缀表达式。
每位同学可必须实现基本要求，可选择实现提高要求；程序可不处理表达式语法错误。
实验目的：掌握堆栈在表达式求值中的应用。
数据结构设计简要描述：序言：这是本学期第三个实验，这个实验比较的基本要求是要我们求出一个已经按后缀表达式形式输入的值，除了之前的堆栈部分，新增了一部分就是判断操作数和运算符，并将操作数入栈，将运算符进行对应的操作数功能实现，并将结果入栈。
数据结构简要设计：本实验主要可分为两个大的模块，一个是堆栈操作，另外一个就是后缀表达式求值操作。
堆栈操作：用结构体类型名来创建用于保存操作数的堆栈，并实现判断栈空、栈满、栈初始化、入栈以及退栈等操作；后缀表达式求值操作：用string类型定义一个字符串，并对其进行判断，是操作数就入栈，是运算符就进行运算，并保存结果。
算法设计简要描述：后缀表达式求值算法：用string类型定义一个字符串，并用一个switch来实现运算符的操作和操作数的入栈，再用一个while来进行循环遍历整个字符串，直到字符串的末尾为止。
最后将算得最终结果退栈，并打印到屏幕上即可。
输入/输出设计简要描述：输入：从键盘上输入一个已经排好序的后缀表达式，如12-82-74-/*输出：屏幕上将输出后缀表达式的值，如上面表达式的值为6编程语言说明：1，编程软件，CodeBlocks 16.0；2，代码均用C++语言实现；3，输入输出采用C++语言的cout和cin函数；4，程序注释采用C/C++规范；主要函数说明：void InitStack(Stack *s);//栈的初始化int EmptyStack(Stack *s);//判断栈空int full(Stack *s);//判断栈满int push(Stack *s,elemtype x);//入栈操作int pop(Stack *s,elemtype &x);//退栈操作int result(string s);//后缀表达式求值程序测试简要报告：见截图：1，2，源程序代码：#include<iostream>#include<malloc.h>using namespace std;typedef int elemtype;//整数型数据类型typedef struct{elemtype *elem;int length;int top;} Stack;//函数声明void InitStack(Stack *s);//栈的初始化int EmptyStack(Stack *s);//判断栈空int full(Stack *s);//判断栈满int push(Stack *s,elemtype x);//入栈操作int pop(Stack *s,elemtype &x);//退栈操作int result(string s);//后缀表达式求值//函数具体实现//顺序存储的栈结构，以及其相应算法void InitStack(Stack *s){s->length = 100;s->elem = (elemtype *)malloc((sizeof(elemtype)*s->length));s->top = -1;}//判断栈是否为空int EmptyStack(Stack *s){return s->top == -1;}//判断栈满int full(Stack *s){return s->top>=s->length-1;}//入栈int push(Stack *s,elemtype x){if(full(s)){return 0;}s->elem[++s->top] = x;return 1;}//退栈int pop(Stack *s,elemtype &x){if(EmptyStack(s)){return 0;}x = s->elem[s->top--];return 1;}//后缀表达式求值函数int result(string s){int Result;//定义一个保存输出结果的值Stack *p;//建栈p = (Stack *)malloc(sizeof(Stack));//为新建的栈分配内存空间InitStack(p);//初始化刚建的栈，这一步不进行的话，入栈将不能进行，之前这个问题将我难到了好久int i = 0;//定义一个字符串下标，用来循环判断字符串中的内容elemtype a,b,d;//定义三个elemtype类型变量，用来进行操作数的实现while(1){if(i>s.length()-1)break;switch(s[i]){case '+'://加号则退两个，并相加将结果保存在栈中 pop(p,a);pop(p,b);d = a + b;push(p,d);break;case '-'://加号则退两个，并相减将结果保存在栈中 pop(p,a);pop(p,b);d = b - a;push(p,d);break;case '*'://加号则退两个，并相乘将结果保存在栈中 pop(p,a);pop(p,b);d = a*b;push(p,d);break;case '/'://加号则退两个，并相除结果保存在栈中 pop(p,a);pop(p,b);d = b/a;push(p,d);break;default://是数字就转换为数字后入栈 d = s[i] - '0';push(p,d);break;}i++;//字符串自增一进行遍历}pop(p,Result);//将计算后的结果退栈cout<<Result<<endl;//输出最后的结果return 0;}int main(){string s;cout<<"请输入一个后缀表达式:\n";cin>>s;cout<<"后缀表达式的值为：\n";result(s);return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
exp[t]='\0';
-2 -
op.top=-1;
ch=str[i];
i++；
while(ch!='\O')
{ switch(ch)
{ case'(':
op.top++;op.data[op.top]=ch;
break;
case')':
while(op.data[op.top]!='(')
{ exp[t]=op.data[op.top];
{ char data[Maxle n];
int top;
}opstack;
typedef struct
{ float data[Maxle n];
int top;
}stack;
void tran s(char str[],char exp[]) //求后缀表达式
{ opstack op;
char ch;
default:
while(ch>='0' && ch<='9')
{ exp[t]=ch;
t++;
ch=str[i];
i++;
i--;
exp[t]='';
t++;
ch=str[i];
i++;
}
while(op.top!=-1)
{ exp[t]=op.data[op.top];
t++;
op.top--;
1
(1)掌握栈“后进先出”的特点；
(2)掌握栈的典型应用一一后缀表达式求值。
2
(1)用键盘输入一个整数后缀表达式(操作数的范围是0〜9，运算符只含•、_、*、/，而且中间 不可以有空格)，使用循环程序从左向右读入表达式；
(2)如果读入的是操作数，直接进入操作数栈；
(3)如果读入的是运算符，立即从操作数栈取出所需的操作数，计算操作数break;
case'*':
case'/':
while(op.top=='/'||op.top=='*')
{ exp[t]=op.data[op.top];
op.top--;
t++；
}
op.top++;
op.data[op.top]=ch;
break;
case' '://输入为空格，则跳过
break;
op.top--;
t++;
}
op.top--;
break;
case'+':
case'-':
while(op.top!=-1 && op.data[op.top]!='(')
{ exp[t]=op.data[op.top];
op.top--;
t++;
}
op.top++;
op.data[op.top]=ch;
(4)检验程序运行结果。
3
(1)分析后缀表达式求值的算法思想，用C(C++)语言完成程序设计。
(2)上机调试通过实验程序。
(3)给出具体的算法分析，包括时间复杂度和空间复杂度等。
(4)撰写实验报告(把输入实验数据及运行结果用抓图的形式粘贴到实验报告上)。
(5)本程序调试通过以后，添加到原教材验证性实验3的菜单中去。
4
⑴实验步骤
我先从具体的问题中抽象出适当的数学模型，然后设计出相应的算法，其中，需要设计一个函 数来求后缀表达式，设计另外一个函数来求后缀表达式的值，最后，编写主函数，串接程序，并调 试程序，得出实验结果。
⑵源代码
#in clude<stdio.h>
#defi ne Maxle n 88
typedef struct