数据结构中算术表达式求值演示源程序
数据结构课程设计(算术表达式求值)-计算器
高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值，并打印求值过程中运算符栈、操作数栈的变化过程。
第二章系统分析开始运行时界面如下：你可以输入一个表达式，按E对其进行求值。
第四章系统实现#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>#define N 100double numStack[N]={0};//操作数栈int numTop;char opStack[N];//运算符栈int opTop;void print_num(double str1[],int n){int i;printf("\n操作数栈：\n");for(i=0;i<n;i++)printf("%g ",str1[i]);}void print_op(char str2[],int m){int j;printf("\n运算符栈：\n");for(j=0;j<m;j++)printf("%c ",str2[j]);}int op(char ch)//判断运算符优先级{if(ch=='+'||ch=='-') return 2;if(ch=='*'||ch=='/') return 3;if(ch=='(') return -1;return 0;}double result(double num1,char op,double num2)//计算{if(op=='+') return num1+num2;if(op=='-') return num1-num2;if(op=='*') return num1*num2;if(op=='/') return num1/num2;return 0;}int compute(char str[]){double num=0;int i=0,j=1,k=1;numTop=opTop=0;while(str[i]!='\0'||opTop>0){if(str[i]>='0'&&str[i]<='9')num=num*10+str[i]-'0';else if( k==1&&str[i]=='-'&&(i==0||op(str[i-1])) )k=-1;else{if(i>0&&!op(str[i-1])&&str[i]!='('&&str[i-1]!=')'){numStack[numTop++]=num*k;if(opTop!=0&&numTop!=0)print_num(numStack,numTop);num=0; j=1; k=1;}if(opTop==0||str[i]=='('){opStack[opTop++]=str[i];print_op(opStack,opTop);}else if(str[i]==')'){while(opTop>0&&opStack[--opTop]!='('){numStack[numTop-2]=result(numStack[numTop-2],opStack[opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop);print_op(opStack,opTop);}numTop--;}if(opStack[opTop]!='(') return 0;}else{if(str[i]=='\0'&&numTop==0) return 0;while(opTop>0&&op(str[i])<=op(opStack[opTop-1])){numStack[numTop-2]=result(numStack[numTop-2],opStack[--opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop-1); print_op(opStack,opTop);}numTop--;}if(str[i]!='\0')opStack[opTop++]=str[i];if(opTop!=0&&numTop!=0)print_op(opStack,opTop);}}if(str[i]!='\0')i++;}if(numTop!=1||opTop!=0)return 0;return 1;}void menu(){system("cls");printf("_______________________________\n");printf(" Clear(C) | Equal(E) | Quit(Q) \n");printf("-------------------------------\n");}int main(void){int i=0,j=0,k;char str[N]="\0";char num[N]="\0";char save[N]="\0";char ch;double temp;unsigned long temp2;menu();printf("input an expression,press key 'E' to compute\n");ch=getch();while( 1 ){if(ch==')'||op(ch)||ch>='0'&&ch<='9'){str[i++]=ch;str[i]='\0';menu();printf("input an expression,press key 'E' to compute\n"); printf("%s",str);if( ch=='-'&&(i==1||op(str[i-2]))||ch>='0'&&ch<='9' ){num[j++]=ch;num[j]='\0';}elsej=0;}if(ch=='C'||ch=='c'){if(strlen(str))str[--i]='\0';menu();printf("input an expression,press key 'E' to compute\n"); printf("%s",str);}if(ch=='E'||ch=='e'){if(compute(str)){printf("\n=%g\n",numStack[0]);j=0; temp=numStack[0];if(temp<0){temp=-temp;num[j++]='-';num[j]='\0';}temp2=(unsigned long)temp;k=1;while(temp2/k>=10) k*=10;while(k){num[j++]=temp2/k+'0';num[j]='\0';temp2=temp2%k;k/=10;}temp=temp-(int)temp;if(temp!=0){num[j++]='.';num[j]='\0';temp+=0.0000005;}for(k=6;k>0;k--){if(temp==0) break;temp*=10;num[j++]=(int)temp+'0';num[j]='\0';temp=temp-(int)temp;}}i=0; j=0; str[0]='\0';}if(ch=='Q'||ch=='q'){printf("\nare you sure to quit?（Y/N）\n");ch=getch();if(ch=='Y'||ch=='y') break;else{menu();printf("input an expression,press key 'E' to compute\n"); printf("%s",str);}}ch=getch();}return 0;}第五章系统测试1.先输入： 3+2*5 后按E求值2.再输入：12/4-5 后按E求值3.再输入Q4.输入Y，退出系统。
数据结构实验报告表达式求值
数据结构实验报告题目：编制一个表达式求值的程序。
一．需求分析1.本演示程序中，利用堆栈存储结构存储读入的运算符，输入的限定范围是数字（0—9），以及+*/()。
输入字符串限定长度为20，可以根据需要进行改变。
如果遇到不是以上范围或者连续输入两个运算符，如：++，则会提示输入错误，请重新输入。
输出的结果是转换后的后序表达式，以及float型数字，不会含有非法字符。
2.演示程序采用的是文件输入，只需要在源代码中输入要输入的文件的地址，然后就可以在文本文件中进行输入，运行过程中会自动读取，输出文本输入的表达式，及运算结果。
3.程序执行的命令包括：1）构造字符优先级比较表，比较优先关系2）文件输入3）构造堆栈，运算符入栈4）堆栈输出，变为后序表达式，并计算5）输出结果，结束4.测试数据文件地址：C:\\Users\\lenovo\\Desktop\\4.txt1) 输入：(35+20/2)*2-4/2+12正确输出结果是：100.00002)输入：(35+20/2)*2-/2+12结果是:error input3) 输入：a+ar/3=135结果是:error input二．概要设计为实现以上程序功能，需运用堆栈用于存储运算符，因此需要定义抽象数据类型。
1.堆栈的抽象数据类型定义为:ADT stack｛数据对象:D={ai|ai∈正整数，i=0，1，2，3，…n,及｛+-*/()｝}数据关系：R1={<ai-1,a1>|ai-1,ai∈D}基本操作：Init stack（&s）操作结果：构造一个空的堆栈sPush stack（&s, e）初始条件：存在堆栈s操作结果:元素e压入堆栈s，top+1Pop （&s，e）初始条件：栈s已经存在且非空操作结果：删除栈顶元素e，输出其值，top-12.程序包含三个模块：1）运算符优先关系模块2）主程序模块;Int main(void){初始化；Do｛接受命令；处理命令；｝while（“命令”=”退出”）；｝3）堆栈模块三．详细设计1.程序源代码解释为：float Result(int c,float r[],int top){ //定义输出结果int j;float temp;switch(c){ //以下是四种基本运算的计算定义，运算完成后直接将top-1值赋予topcase 42:r[top-1]=r[top-1]*r[top];top=top-1;break; //乘法case 43:r[top-1]=r[top-1]+r[top];top=top-1;break;///加法case 45:r[top-1]=r[top-1]-r[top];top=top-1;break;//减法case 47:r[top-1]=r[top-1]/r[top];top=top-1;break;// 除法case 94:for(j=1,temp=r[top-1];j<r[top];j++) //平方或者几次方的运算temp=r[top-1]*temp; //循环相乘r[top-1]=temp;top=top-1;break;}return(r[top]);}if(temp1!=1){while(top>=1){ //栈不空的时候，栈中元素赋给houzhi，并计数biaozhi[b++]=i;houzhi[i]=duizhan[top-1];top=top-1;i=i+1;}max=i; //从0到i循环输出后序表达式for(i=0,b=0;i<max;i++){if(i!=biaozhi[b])printf("%d ",houzhi[i]) ; //输出后序表达式中的数字else {printf("%c ",houzhi[i]); //输出后序表达式中的运算符b=b+1;}}top=-1;for(i=0,b=0;i<max;i++){ //从0到maxif(i!=biaozhi[b]){top=top+1;result[top]=houzhi[i]; //将后值赋予result，调用result函数，进行Result运算}else {Result(houzhi[i],result,top); //运算结束，输出栈顶值，既是运算结果top--;b=b+1;}}printf("\n\nThe result is %f ",Result(houzhi[i],result,top)); //输出并打印结果}}getch();return 0;///返回0}2.程序的模块调用：主程序↓文件打开读入字符↓输入字符有效及优先级的判断↓运算模块↓输出结果四.调试分析1.本次作业的核心就是利用堆栈将中序表达式改成后序表达式，然后进行表达式的求值。
数据结构-算术表达式求值(含需求分析和源代码)
需求分析(附代码)一、需求分析（1）首先定义两个栈OPTR、OPND，栈OPTR用于存放运算符，栈OPND 用于存放操作数；定义一个一维数组expr【】存放表达式串。
（2）主函数主要包括两部分：（1）判断运算符优先权，返回优先权高的；（2）操作函数。
（3）开始将‘#’入操作符栈，通过一个函数来判别算术运算符的优先级。
且规定‘#’的优先级最低。
在输入表达式的最后输入‘#’，代表表达式输入结束。
在表达式输入过程中，遇操作数则直接入栈。
遇到运算符则与栈顶运算符比较优先级,当前运算符优先级高(前面的运算还不应执行)则当前运算符入栈,扫描下一符号;否则栈顶运算符出栈,两操作数出栈,进行运算,所得结果入数栈,重新比较当前运算符(注意当前运算符未变)与新栈顶运算符。
如此重复直到栈顶运算符与当前符号均为‘#’，运算结束。
（4）最初实现的加、减、乘、除及带小括号的基本运算，但考虑到实用性，后来的设计中有加上了乘方运算。
在乘方运算中借用了C库中自带的乘方函数pow。
二、概要设计1、设定栈的抽象数据类型定义：ADT Stack {数据对象：D＝{ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系：R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }约定an端为栈顶，a1端为栈底。
基本操作：InitStack(&S)操作结果：构造一个空栈S。
DestroyStack(&S)初始条件：栈S已存在。
操作结果：栈S被销毁。
StackEmpty(S)初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则FALE。
StackLength(S)初始条件：栈S已存在。
操作结果：返回S的元素个数，即栈的长度。
GetTop(S, &e)初始条件：栈S已存在且非空。
操作结果：用e返回S的栈顶元素。
ClearStack(&S)初始条件：栈S已存在。
c_语言_算术表达式的求值__数据结构_课程设计
//算术表达式的求值//济南大学信息学院计算机数据结构课程设计/*【问题描述】表达式计算式实现程序设计语言的的基本问题之一，也是栈的应用的一个典型例子，设计一个程序，演示用运算符优先法对算术表达式的求值的过程。
*///main.cpp#include "iostream.h"#include "stdlib.h"#include "public.h"#include "stack.h"//using namespace std;LinkStack OPTR;//操作符栈int Allnum[100]={0}; //储存所有的运算数int NUM[100]={0};//操作数栈int n=0;void calcu(){int x1,x2,x;char p;//弹出一个运算符Pop(OPTR,p);//弹出两个操作数x2=NUM[n--];x1=NUM[n--];//进行一次运算switch(p) {case '+':x=x1+x2;break;case '-':x=x1-x2;break;case '*':x=x1*x2;break;case '/':x=x1/x2;//结果压入操作数栈NUM[++n]=x;}int EvaluateExpression(char *p){InitStack(OPTR);InitStack(OPND);int i=0;char temp;int num=0;while( *p!='\0' )switch(*p){case '+': case '-':while ( (GetTop(OPTR,temp))!=ERROR && (temp!='('))//执行先遇到的加、减运算calcu();//当前运算符进栈Push(OPTR,*p);//读下一个字符p++;break;case '*': case '/':if ( GetTop(OPTR,temp)==OK && (temp=='*') || (temp=='/')) //执行先遇到的乘、除运算calcu();//当前运算符进栈Push(OPTR,*p);//读下一个字符p++;break;case '('://左括号进栈Push(OPTR,*p);//读下一个字符p++;break;case ')':while ( GetTop(OPTR,temp)==OK && temp!='(' )//执行括号内的加、减、乘、除运算calcu();//弹出左括号char e;Pop(OPTR,e);//读下一个字符p++;break;default://把字符串转换成整数值//int num=strInt(p);num=0;do {num=10*num+*p-'0';p++;} while((*p>='0')&&(*p<='9'));//char strnum[10];//NumString(num,strnum);//将num转换为字符串strnum//操作数进栈NUM[++n]=num;//s1[++t1]=v;Allnum[i++]=num;};while ( GetTop(OPTR,temp)==OK )calcu();//返回结果//printf("%d \n",NUM[1]);return NUM[n];}//EvaluateExpressionvoid main(){char a[100];//="5+(9-2*3)^2+3*(2+1)"; //="5*(40+6)-39";5+(9-2*3)^2+3*(2+1)int i=0;start:cout<<"算数表达式:_" ;cin>>a;cout<<EvaluateExpression(a)<<endl;//system("pause");cout<<"----------------"<<endl;goto start;}//public.henum Status{OK,ERROR,}; //定义枚举类型int strInt(char *p){//把字符串转换成整数值int num=0;do {num=10*num+*p-'0';p++;} while((*p>='0')&&(*p<='9'));return num;}///////////数字转换字符串void convert(int abc,char a[],int &i_num){if( abc/10!=0 )convert(abc/10,a,i_num);a[i_num]=abc%10+'0';i_num++;}void NumString(int abc,char a[]){if(abc<0) abc=-abc;int i_num=0;convert(abc,a,i_num);a[i_num]='\0';}//////////////////stack.h//typedef char char;typedef struct SNode{char data; //数据域struct SNode *next; //指针域}SNode,*LinkStack; //定义链栈结点Status InitStack( LinkStack &S ){//将S初始化为一个空的链栈S=( LinkStack ) malloc ( sizeof( SNode ) );if( S==NULL ) return ERROR; //内存空间申请不成功S->next=NULL;return OK;}Status DestroyStack(LinkStack &S){//销毁栈SLinkStack p;while(S->next){p=S->next;S->next=p->next;free(p);}free(S);return OK;}Status StackIsEmpty(LinkStack S){//判断栈是否为空if (S->next==NULL) return OK;return ERROR;}Status Push(LinkStack &S, char e){//将数据元素e插入到栈S的栈顶LinkStack p;p=( LinkStack ) malloc ( sizeof( SNode ) );if( p==NULL ) return ERROR;p->data=e;p->next=NULL; //创建新结点p->next=S->next;S->next=p; //插入return OK;}Status Pop(LinkStack &S, char &e){//将栈S的栈顶元素出栈，并存放到e中LinkStack p;if( S->next==NULL ) return ERROR; //空队出错p=S->next; //记住要删除的结点S->next=p->next; //栈顶元素p出栈e=p->data;free(p); //释放存储空间return OK;}Status GetTop(LinkStack S, char &e){LinkStack p;//char e;if( S->next==NULL ) return ERROR; //空队出错p=S->next;e=p->data;return OK;}。
数据结构实验二——算术表达式求值实验报告
《数据结构与数据库》实验报告实验题目算术表达式求值学院：化学与材料科学学院专业班级：09级材料科学与工程系PB0920603姓名：李维谷学号：PB09206285邮箱：liwg@指导教师：贾伯琪实验时间：2010年10月10日一、需要分析问题描述：表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。
设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时，借助栈实现。
设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。
算法规定：输入形式：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。
为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。
输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。
程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。
测试数据：正确输入：12*（3.6/3+4^2-1）#输出结果：194.4无定义运算：12*（3.6/（2^2-4）+1）# 输出结果：表达式出错，除数为0，无意义 错误输入：12+s# 输出结果：ERROR ！ 二、 概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
程序中将涉及下列两个抽象数据类型：1、设定“操作数”的栈的抽象数据类型定义： ADT SqStack_f{数据对象：D={i a },+∈∈N i R a i数据关系：R1={<1,-i i a a >|1-i a ,D a i ∈,i=2,…，n}约定n a 端为栈顶，i a 端为栈底。
表达式求值源代码(数据结构课程设计)
}
else if(flog2==0)
{
printf("您还没有判断表达式的正确性!\n请您按照规定先判断表达式的正确性后查看算术表达式的中缀表达式\n\n\n");
break;
}
else
{
postfix(a,b);
printf("后缀表达式为：\n");
i=0;
do
{
printf("%c",b[i]);
scanf("%c",&w);
if(w=='n')
{
printf("您的操作已取消!\n\n\n");
break;
}
else if(w=='y')
{
printf("请输入算术表达式：(以#号结尾!) ");
i=0;
do
{
scanf("%c",&a[i]);
}while(a[i++]!='#');
flog=1;
}
else
{
printf("表达式不符合要求!\n请重新输入!\n");
break;
}
}
break;
case '3':
if(flog==0)
{
printf("您还没有输入过表达式!\n请您按照规定先输入后算术表达式的中缀表达式\n\n\n");
break;
}
else if(flog2==0)
{
printf("您还没有判断表达式的正确性!\n请您按照规定先判断表达式的正确性后查看算术表达式的中缀表达式\n\n\n");
数据结构实验报告-算术表达式求值
- - 1．前言12．概要设计12.1 数据构造设计12.2 算法设计12.3 ADT描述22.4 功能模块分析23．详细设计33.1 数据存储构造设计33.2主要算法流程图〔或算法伪代码〕44．软件测试75．心得体会8参考文献8附录9- -优质-..1．前言在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进展。
因而在程序设计时，借助栈实现。
算法输入：一个算术表达式，由常量、变量、运算符和括号组成〔以字符串形式输入〕。
为简化，规定操作数只能为正整数，操作符为+、-*、/，用#表示完毕。
算法输出：表达式运算结果。
算法要点：设置运算符栈和运算数栈辅助分析算符优先关系。
在读入表达式的字符序列的同时，完成运算符和运算数的识别处理，以及相应运算。
2．概要设计2.1 数据构造设计任何一个表达式都是由操作符，运算符和界限符组成的。
我们分别用顺序栈来存放表达式的操作数和运算符。
栈是限定于紧仅在表尾进展插入或删除操作的线性表。
顺序栈的存储构造是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置，base为栈底指针，在顺序栈中，它始终指向栈底，即top=base可作为栈空的标记，每当插入新的栈顶元素时，指针top增1，删除栈顶元素时，指针top减1。
2.2 算法设计为了实现算符优先算法。
可以使用两个工作栈。
一个称为OPTR，用以存放运算符，另一个称做OPND，用以存放操作数或运算结果。
1.首先置操作数栈为空栈，表达式起始符〞#〞为运算符栈的栈底元素；2.依次读入表达式，假设是操作符即进OPND栈，假设是运算符那么和OPTR栈的栈顶运算符比拟优先权后作相应的操作，直至整个表达式求值完毕〔即OPTR栈的栈顶元素和当前读入的字符均为〞. .word.zl.数据构造课程设计第 2 页#〞〕。
最新《数据结构》算术表达式求值
二课程设计2——算术表达式求值一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码三感想体会与总结算术表达式求值一、需求分析一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。
假设操作数是正整数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。
引入表达式起始、结束符是为了方便。
编程利用“算符优先法”求算术表达式的值。
二、程序的主要功能（1）从键盘读入一个合法的算术表达式，输出正确的结果。
（2）显示输入序列和栈的变化过程。
三、程序运行平台Visual C++ 6.0版本四、数据结构本程序的数据结构为栈。
（1）运算符栈部分：struct SqStack //定义栈{char *base; //栈底指针char *top; //栈顶指针int stacksize; //栈的长度};int InitStack (SqStack &s) //建立一个空栈S{if (!(s.base = (char *)malloc(50 * sizeof(char))))exit(0);s.top=s.base;s.stacksize=50;return OK;}char GetTop(SqStack s,char &e) //运算符取栈顶元素{if (s.top==s.base) //栈为空的时候返回ERROR{printf("运算符栈为空!\n");return ERROR;}elsee=*(s.top-1); //栈不为空的时候用e做返回值，返回S的栈顶元素，并返回OKreturn OK;}int Push(SqStack &s,char e) //运算符入栈{if (s.top-s.base >= s.stacksize){printf("运算符栈满!\n");s.base=(char*)realloc (s.base,(s.stacksize+5)*sizeof(char) ); //栈满的时候，追加5个存储空间if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=5;}*(s.top)++=e; //把e入栈return OK;}int Pop(SqStack &s,char &e) //运算符出栈{if (s.top==s.base) //栈为空栈的时候，返回ERROR{printf("运算符栈为空!\n");return ERROR;}else{e=*--s.top; //栈不为空的时候用e做返回值，删除S的栈顶元素，并返回OKreturn OK;}}int StackTraverse(SqStack &s) //运算符栈的遍历{char *t;t=s.base ;if (s.top==s.base){printf("运算符栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %c",*t); //栈不为空的时候依次取出栈内元素t++;}return ERROR;}（2）数字栈部分：struct SqStackn //定义数栈{int *base; //栈底指针int *top; //栈顶指针int stacksize; //栈的长度};int InitStackn (SqStackn &s) //建立一个空栈S{s.base=(int*)malloc(50*sizeof(int));if(!s.base)exit(OVERFLOW); //存储分配失败s.top=s.base;s.stacksize=50;return OK;}int GetTopn(SqStackn s,int &e) //数栈取栈顶元素{if (s.top==s.base){printf("运算数栈为空!\n"); //栈为空的时候返回ERRORreturn ERROR;}elsee=*(s.top-1); //栈不为空的时候，用e作返回值，返回S的栈顶元素，并返回OKreturn OK;}int Pushn(SqStackn &s,int e) //数栈入栈{if (s.top-s.base >=s.stacksize){printf("运算数栈满!\n"); //栈满的时候，追加5个存储空间s.base=(int*)realloc (s.base,(s.stacksize+5)*sizeof(int) );if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize; //插入元素e为新的栈顶元素s.stacksize+=5;}*(s.top)++=e; //栈顶指针变化return OK;}int Popn(SqStackn &s,int &e) //数栈出栈{if (s.top==s.base){printf(" 运算符栈为空!\n"); //栈为空栈的视时候，返回ERRORreturn ERROR;}else{e=*--s.top; //栈不空的时候，则删除S的栈顶元素，用e返回其值，并返回OKreturn OK;}}int StackTraversen(SqStackn &s) //数栈遍历{int *t;t=s.base ;if (s.top==s.base){printf(" 运算数栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %d",*t); //栈不为空的时候依次输出t++;}return ERROR;}五、算法及时间复杂度1、算法：建立两个不同类型的空栈，先把一个‘# ’压入运算符栈。
数据结构课程设计之算术表达式求值
1【实验题目及要求】[问题描述]一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。
假设操作数是正实数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。
引入表达式起始、结束符是为了方便。
编程利用“算符优先法”求算术表达式的值。
[基本要求]（1）从键盘或文件读入一个合法的算术表达式，输出正确的结果。
（2）显示输入序列和栈的变化过程。
（3）考虑算法的健壮性，当表达式错误时，要给出错误原因的提示。
(4) 实现非整数的处理（可选功能）。
2【源代码（C语言）】#include<stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20#define OK 1#define ERROR 0#define OVERLOW 0#define YES 1#define NO 0typedefstruct{char * base;char * top;int stacksize; //最大存储量}OPTR; //字符存储栈typedefstruct{float *base;float *top;int stacksize; //最大存储量}OPND; //数值存储栈int InitOptrStack(OPTR *); //字符栈初始化函数int OptrPush(OPTR *, char); //进字符栈操作int OptrPop(OPTR*, char *); //出字符栈操作int OptrEmpty(OPTR ); //判断字符栈是否为空char GetOptrTop(OPTR); //返回字符栈顶元素int InitOpndStack(OPND *); //数值栈初始化函数int OpndPush(OPND *, float); //进数值栈操作int OpndPop(OPND*, float*); //出数值栈操作int OpndEmpty(OPND ); //判断数值栈是否为空int JudgeChar(char); //判断是否为字符float GetFloat(char *); //接收一个数字char Precede(char, char); //判断优先级操作float Caculate(float,float,char);//计算数值{char ch, noMean, ci;float num, number1, number2;OPTR optr;OPND opnd;//system("color 30");InitOptrStack(&optr);InitOpndStack(&opnd);while(1){printf(" 请输入表达式以“#”开始，以“#”结束\n ");do{ch = getchar();}while(ch !='#'); //忽略前面非‘#’字符OptrPush(&optr, ch);ch = getchar();while(ch != '#' || GetOptrTop(optr) != '#'){if(!JudgeChar(ch)){ //如果输入的是数字num = GetFloat( &ch );OpndPush(&opnd, num);else{ //输入的是字符switch(Precede(GetOptrTop(optr),ch)){case'<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case'=':OptrPop(&optr,&noMean); //左右括号，把左括号出栈ch = getchar ();break;case'>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd,&number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符！\n");system ("PAUSE");exit(0);}break;}//witch}//else}if(opnd.top -opnd.base >= 2){printf(" 俩个括号之间缺少运算符！\n ");system ("PAUSE");exit( 0 );}OpndPop(&opnd,&num); //直接把OPND的栈元素赋值给numprintf(" 运算结果为%.3f\n", num);}system ("PAUSE");}int InitOptrStack(OPTR * OP){OP->base = (char*)malloc((MAXSIZE+1)*sizeof(char));OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OptrPush(OPTR *OP, char ch){*(OP->top) = ch;OP->top++;return OK;}int OptrPop(OPTR *OP, char *ch){if(OP->base == OP->top)return ERROR;else{OP->top--;*ch = *(OP->top);return OK;}}int OptrEmpty(OPTR OP){if(OP.top == OP.base )return YES;elsereturn NO;}char GetOptrTop(OPTR OP){return *(OP.top -1);}int InitOpndStack(OPND * OP){if(!(OP->base = (float*)malloc((MAXSIZE+1)*sizeof(float)))) exit(OVERLOW);OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OpndPush(OPND *OP, float number) {*(OP->top) = number;OP->top++;return OK;}int OpndPop(OPND *OP, float* number) {if(OP->top == OP->base)return ERROR;else{OP->top--;*number = *(OP->top);return OK;}}int OpndEmpty(OPND OP){if(OP.top == OP.base )return YES;elsereturn NO;}int JudgeChar(char ch){if(ch>='0'&&ch<= '9')return NO;elsereturn YES;}float GetFloat(char* ch){int i;float num = 0;for( i = 0; *ch>= '0'&& *ch<= '9'; i++){ num = num*10 + *ch - '0';*ch = getchar();}return num;}char Precede(char a, char b){char ch;switch(a){case'+':case'-': if(b == '*' || b == '/' || b == '(')ch = '<';elsech = '>';break;case'*':case'/': if( b == '(')ch = '<';elsech = '>';break;case'(': if(b == ')')ch = '=';elseif(b == '#'){printf(" 缺少反括号\n");system ("PAUSE");exit(0);}elsech = '<';break;case')': if(b == '('){printf(" 两个括号之间没有符号相连！\n");system("PAUSE");exit(0);}ch = '>';break;case'#': if(b == '#')ch = '=';elseif(b == ')'){printf(" 没有左括号！\n ");system("PAUSE");exit(0);}elsech = '<';break;default: printf(" 输入运算符超出范围! \n ");system ("PAUSE");exit(0);break;}return ch;}float Caculate(float number1, float number2, char ci){float num;switch( ci){case'+': num = number1 + number2; break;case'-': num = number1 - number2; break;case'*': num = number1 * number2; break;case'/': num = number1 / number2; break;}return num;}3【算法思想】根据栈的原理，建立数字栈OPND和运算符号栈OPTR，对读入的字符进行判断，存入不同的栈内，每次读入一个字符就把该字符和运算符栈顶的优先级进行比较，然后选择相应的操作，这是这个程序的核心代码，如下：switch(Precede(GetOptrTop(optr),ch)){case '<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case '=':OptrPop(&optr,&noMean); //左右括号，把左括号出栈ch = getchar ();break;case '>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd, &number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符！\n");system ("PAUSE");exit(0);}break;}//witch4【实现效果】完全可以实现题目的要求，除了下图的错误提示，本程序还可以提示的错误有：输入过多运算符，缺少反括号，两个括号之间缺少运算符相连，缺少左括号，输入的运算符超出范围等提示。
数据结构课程设计报告-中缀算术表达式求值
课程设计报告课程名称数据结构课题名称中缀算术表达式求值专业通信工程班级通信0902学号姓名指导教师2011 年07 月01 日湖南工程学院课程设计任务书课程名称数据结构课题中缀算术表达式求值专业班级通信工程0902学生姓名学号指导老师审批任务书下达日期2011 年06 月27日任务完成日期2011 年07 月01日设计要求：1. 课程设计报告规范（1）需求分析a.程序的功能。
b.输入输出的要求。
（2）概要设计a.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系；每个模块的功能。
b.课题涉及的数据结构和数据库结构；即要存储什么数据，这些数据是什么样的结构，它们之间有什么关系等。
（3）详细设计a.采用C语言定义相关的数据类型。
b．写出各模块的类C码算法。
c.画出各函数的调用关系图、主要函数的流程图。
（4）调试分析以及设计体会a.测试数据：准备典型的测试数据和测试方案，包括正确的输入及输出结果和含有错误的输入及输出结果。
b.程序调试中遇到的问题以及解决问题的方法。
c.课程设计过程经验教训、心得体会。
（5）使用说明用户使用手册：说明如何使用你编写的程序，详细列出每一步的操作步骤。
（6）书写格式a.设计报告要求用A4纸打印成册：b.一级标题用3号黑体,二级标题用四号宋体加粗,正文用小四号宋体;行距为22。
（7）附录源程序清单（带注释）2. 考核方式指导老师负责验收程序的运行结果，并结合学生的工作态度、实际动手能力、创新精神和设计报告等进行综合考评，并按优秀、良好、中等、及格和不及格五个等级给出每位同学的课程设计成绩。
具体考核标准包含以下几个部分：（1）平时出勤（占10%）（2）系统需求分析、功能设计、数据结构设计及程序总体结构合理与否（占10%）（3）程序能否完整、准确地运行，个人能否独立、熟练地调试程序（占40%）（4）设计报告（占30%）注意：不得抄袭他人的报告（或给他人抄袭），一旦发现，成绩为零分。
算术表达式求值演示-课程设计报告
算术表达式求值演示目录第一章概述 (1)第二章系统分析 (1)第三章概要设计 (2)第四章详细设计 (5)第五章运行与测试 (13)第六章总结与心得 (16)参考文献 (16)第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
课程设计是让同学们对所学的课程更全面的学习和应用，理解和掌握课程的相关知识。
《数据结构》是一门重要的专业基础课，是计算机理论和应用的核心基础课程。
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是算术表达式求值演示。
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。
设计一个程序，演示用算符优先法对算术表达式求值的过程。
深入了解栈和队列的特性，以便在解决实际问题中灵活运用它们，同时加深对这种结构的理解和认识。
第二章系统分析1．以字符列的形式从终端输入语法正确的、不含变量的整数表达式。
利用已知的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。
2．一般来说，计算机解决一个具体问题时，需要经过几个步骤：首先要从具体问题抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编出程序，进行测试，调试直至得到想要的答案。
对于算术表达式这个程序，主要利用栈，把运算的先后步骤进行分析并实现简单的运算！为实现算符优先算法，可以使用两个栈，一个用以寄存运算符，另一个用以寄存操作数和运算结果。
3．演示程序是以用户于计算机的对话方式执行，这需要一个模块来完成使用者与计算机语言的转化。
4．程序执行时的命令：本程序为了使用具体，采用菜单式的方式来完成程序的演示，几乎不用输入什么特殊的命令，只需按提示输入表达式即可。
数据结构课程设计带括号的算术表达式求值
、实验的目的和要求1.采用算符优先数算法, 能正确求值表达式;2.熟练掌握栈的应用;3•熟练掌握计算机系统的基本操作方法，了解如何编辑、编译、链接和运行一个C++程序; 4.上机调试程序,掌握查错、排错使程序能正确运行。
三、实验的环境:指硬件和软件环境1.硬件环境: Intel 奔腾双核T2390 双核处理器(1.86GHz 主频/1MB 二级缓存/533MHz 前端总线)， RAM:2G .2.软件环境: 操作系统：windows vista编译软件：Microsoft Viual C++6.03.软件环境介绍:Visual C++是一个功能强大的可视化软件开发工具。
自1993年Microsoft公司推出Visual C++1.0后，随着其新版本的不断问世，Visual C++已成为专业程序员进行软件开发的首选工具。
虽然微软公司推出了Visual C++.NET(Visual C++7.0) ，但它的应用的很大的局限性，只适用于Windows 2000,Windows XP 和Windows NT4.0。
所以实际中，更多的是以Visual C++6.0 为平台。
Visual C++6.0不仅是一个C++编译器，而且是一个基于Windows操作系统的可视化集成开发环境( integrated development environment,IDE )。
Visual C++6.0 由许多组件组成，包括编辑器、调试器以及程序向导AppWizard 、类向导Class Wizard 等开发工具。
这些组件通过一个名为Developer Studio 的组件集成为和谐的开发环境。
四、算法描述:1.头文件:Stack.hCalculator.hMethod:Stack method:Push(); // 进栈操作Pop(); // 出栈操作GetHead(); // 返回栈中的最顶层元素MakeEmpty(); // 清空栈操作Calculator method:Calculator();// 计算主体celarstream(); // 清空输入流Prior();// 返回运算符的优先级done(); // 做一次二元运算output(); // 打印结果并输出EnEmpty(); // 调用MakeEmpty(), 并清空栈2.cpp 文件Calculator.cppMethod:int main(); // 主程序3.程序流程图优先级比较算法Data 算法存放操作字符 存放数据调用 Calculator 。
数据结构实验报告——四则运算表达式求值
数据结构实验报告——四则运算表达式求值实验五四则运算表达式求值一．问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
二．基本要求：使用二叉树来实现。
三．实现提示：利用二叉树后序遍历来实现表达式的转换，同时可以使用实验二的结果来求解后缀表达式的值。
输入输出格式：输入：在字符界面上输入一个中缀表达式，回车表示结束。
输出：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
测试实例：输入：21+23* （12-6 ）输出：21 23 12 6 -*+四．设计概要用二叉树表示表达式：若表达式为数或简单变量，则相应二叉树中仅有一个根结点，其数据域存放该表达式信息若表达式= （第一操作数）（运算符）（第二操作数），则相应的二叉树中以左子树表示第一操作数，右子树表示第二操作数，根结点的数据域存放运算符（若为一元算符，则左子树空）。
操作数本身又为表达式.后缀遍历二叉树码实现和静态检查上机调试及测试数据的调试五．源程序：#include#include#include#include#include#include#define STACK_INIT_SIZE 100#define DATA_SIZE 10#define STACKINCREMENT 10#define OK 1#define TRUE 1#define FALSE 0#define ERROR 0#define OVERFLOW -2using namespace std;typedef float SElemtype;typedef int Status;typedef char * TElemType;typedef struct BiTNode {TElemType data;int len; //data字符串中字符的个数struct BiTNode * lchild, * rchild;}BiTNode, *BiTree;typedef struct{SElemtype *base;SElemtype *top;int stacksize;} SqStack;Status IsDigital(char ch)if(ch>='0'&&ch<='9'){return 1; //是数字字母}return 0; //不是数字字母}int CrtNode(stack &PTR, char *c){BiTNode * T;int i=0;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));while(IsDigital(c[i])){T->data [i] = c[i];i++;}T->len = i;T->lchild = T->rchild = NULL;PTR.push (T);return i;}void CrtSubTree(stack &PTR, char c){BiTNode * T;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));T->data [0] = c;T->len = 1;T->rchild = PTR.top(); //先右子树，否则运算次序反了PTR.pop ();T->lchild = PTR.top();PTR.pop ();PTR.push (T);}char symbol[5][5]={{'>', '>', '<', '<', '>'}, //符号优先级{'>', '>', '<', '<', '>'},{'>', '>', '>', '>', '>'},{'>', '>', '>', '>', '>'},{'<', '<', '<', '<', '='}};int sym2num(char s) //返回符号对应优先级矩阵位置{switch(s){case '+': return 0; break;case '-': return 1; break;case '*': return 2; break;case '/': return 3; break;case '#': return 4; break;}}char Precede(char a, char b) //返回符号优先级{return(symbol[sym2num(a)][sym2num(b)]);void CrtExptree(BiTree &T, char exp[]){//根据字符串exp的内容构建表达式树Tstack PTR;//存放表达式树中的节点指针stack OPTR;//存放操作符char op;int i=0;OPTR.push ('#');op = OPTR.top();while( !((exp[i]=='#') && (OPTR.top()=='#')) ) //与{ if (IsDigital(exp[i])){//建立叶子节点并入栈PTRi+=CrtNode(PTR, &exp[i]);}else if (exp[i] == ' ')i++;else{switch (exp[i]){case '(': {OPTR.push (exp[i]);i++;break;}case ')': {op = OPTR.top (); OPTR.pop ();while(op!='('){CrtSubTree(PTR, op);op = OPTR.top (); OPTR.pop ();}//end whilei++;break;}default: //exp[i]是+ - * /while(! OPTR.empty ()){op = OPTR.top ();if (Precede(op, exp[i])=='>'){CrtSubTree(PTR, op);OPTR.pop ();}if(exp[i]!='#'){OPTR.push (exp[i]);i++;}break;}}//end switch}//end else}//end whileT = PTR.top();PTR.pop ();}void PostOrderTraverse(BiTree &T, char * exp ,int &count){//后序遍历表达式树T，获取树中每个结点的数据值生成逆波兰表达式exp //T是表达式树的根节点；字符串exp保存逆波兰表达式；count保存exp中字符的个数//后序遍历中，处理根结点时，依据T->len的值，把T->data中的字符依次添加到当前exp字符串的尾端//添加完T->data后，再添加一个空格字符，同时更新count计数器的值。
数据结构表达式求值完整篇(含实验报告)
2.操作数和运算符分别入不同的栈
char->int 进操作数栈
先考虑了小于10的整数直接进栈,重点是运算符的优先级这块函数的编写
3前面的都听简单的，就是小数编写这块想了很久，
将单个字符转为整数后还要定一个double p;使依次输入的数成一个小数->p.
}
//操作数栈初始化
void OPND_InitStack(Sqstack_OPND &s)
{
s.base=new SElemType_OPND[MAXSIZE];
if(!s.base)
printf("\n操作数栈存储分配失败!\n");
s.top=s.base;
s.stacksize=MAXSIZE;
if(ch != '.' )
{
if ( dimo != '.' )
{
p = p*10 ;
p += (ch-'0');
scanf("%c",&ch);
}
else if ( dimo == '.')
{
p = p+(ch-'0')*q;
q=q*q;;
scanf("%c",&ch#39;.' )
}
//操作数入栈
void OPND_Push(Sqstack_OPND &s,SElemType_OPND e)
{
if(s.top-s.base == s.stacksize)
printf("\n满栈!\n");
数据结构——算术表达式求值算法
沈阳航空航天大学课程设计报告课程设计名称：数据结构课程设计课程设计题目：算术表达式求值算法院（系）：计算机学院专业：计算机科学与技术班级：学号：姓名：指导教师：***完成日期：2013年01月11日沈阳航空航天大学课程设计报告目录第1章概要设计 (1)1.1题目的内容与要求 (1)1.2总体结构 (1)第2章详细设计 (3)2.1栈的顺序存储模块 (3)2.2进栈模块 (3)2.3出栈模块 (4)2.4运算模块 (4)2.5判断优先级模块 (5)2.6处理表达式主体模块 (6)第3章调试分析 (8)第4章运行结果 (9)参考文献 (11)附录（程序清单） (12)第1章概要设计1.1题目的内容与要求内容：设计程序，其能够求解任意给定算数表达式的值，算数表达式中的操作符来自于集合{+，－，*，＼}，表达式允许包括小括号“（）”，表达式的输入以“#”作为结束标志。
要求：1)利用栈结构实现表达式求值算法，即在约定的条件下，正确输入表达式，经过程序的运行之后，给出表达式的值；2)系统利用C语言实现；3)独立完成系统的设计、编码和调试。
1.2总体结构本程序主要分为六个模块（主要算法模块图见图1.1）：栈的顺序存储模块、进栈模块、出栈模块、运算模块、判断优先级模块、处理表达式主体模块。
栈的顺序存储模块：分别建立两个栈，第一个用来存储运算符，第二个是用来存储数字。
进栈模块：运算符和数字分别存储在运算符栈和数字栈中，以便运算时的调用。
出栈模块：由于运算的需要，就必须把运算符和数字分别从运算符栈和数字栈中取出来。
运算模块：程序在遇到运算符的时候，根据此模块的要求进行运算。
判断优先级模块：找出栈顶算符和即将入栈算符的对应的下标，然后根据算符间的优先关系表判断出算符的优先关系。
处理表达式主体模块：结合运算模块和判断优先级模块，对表达式进行系统处理，求出算数表达式的值。
图1.1 主要算法模块图第2章详细设计在本次课程设计中，我们用到了栈这个重要的数据结构。
数据结构实习报告_设计一个演示用运算优先法对算数表达式求值过程的程序。
实习报告题目：设计一个演示用运算优先法对算数表达式求值过程的程序。
班级：姓名：学号：完成日期：一、需求分析1建立运算数栈SqStack1和运算符栈SqStack2辅助分析算符有限关系.2用户输入以“#”结尾的算数表达式，本程序需要用户自行输入表达式（运算符可以是加（+）；减（-）；乘（*）；除（/）；括号（（））），以字符形式读入，在读入的同时，完成运算符和运算数的识别处理，在识别出运算数的同时，要将其字符序列形式转换成整数形式。
3在程序的适当位置输出运算符栈、运算数栈、输入字符和主要操作的内容，即演示运算操作。
4测试数据见原题。
5程序执行的命令包括：（1）建立算数表达式；（2）得到运算表达式的值；（3）演示运算过程。
二、概要设计1.设定栈的抽象数据类型定义：ADT Stack{数据对象D＝{ ai | ai ∈charSet, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }（约定an 端为栈顶，a1 端为栈底）基本操作：InitStack（&S）操作结果：构造一个空栈S。
Gettop(S,&e)初始条件：栈S已存在。
操作结果：若栈S不空，则以e返回栈顶元素。
Push(&S,e)初始条件：栈 S 已存在。
操作结果：插入元素 e 为新的栈顶元素。
Pop(&S,&e)初始条件：栈 S 已存在且非空。
操作结果：删除 S 的栈顶元素，并用 e 返回其值。
}ADT Stack2.本程序包括三个模块（1）主程序模块：Void main( ){初始化；函数；}（2）栈模块——实现栈抽象数据类型（3）运算模块——实现运算并演示其过程模块各模块之间调用关系如下：主程序模块运算模块栈模块三、详细设计1、元素类型、结点类型typedef struct{int *base;int *top;int stacksize;}SqStack1; //操作数栈typedef struct{char *base;char *top;int stacksize;}SqStack2; //操作符栈2、栈类型typedef struct{char *base;char *top;int stacksize;}Stack; //栈类型栈的基本操作设置如下：void InitStack(Stack &S)//初始化，设S为空栈（S.top=NULL）Status GetTop(Stack S,ElemType e)//若栈S不空，则以e带回栈顶元素并返回TRUE，否则返回FALSE Status Push(Stack&S,ElemType e)//若分配空间成功，则在S的栈顶插入新的栈顶元素e，并返回TRUE，//否则返回FALSE其中部分操作的算法：Status Push(Stack &S,ElemType e){//若分配空间成功，则在S的栈顶插入新的栈顶元素e，并返回TRUE；//否则栈不变，并返回FALSEif(MakeNode(p,e)){P.next=S.top;S.top=p;S.size++;Return TRUE;}else return FALSE;}Status Pop(Stack &S,ElemType &e){//若栈不空，则删除S的栈顶元素并以e带回其值，且返回TRUE，//否则返回FALSE，且e无意义if(StackEmpty(S)) return FALSE;else{p=S.top;S.top=S.top->next;e=p->:data;S.size--;return TRUE;}}3、运算代码int Operate(int a,char theta,int b) //计算表达式值：主要是将大的表达式转化成小的表达式进行逐步求值{int c;if(theta=='+') c=a+b;else if(theta=='-') c=a-b;else if(theta=='*') c=a*b;else c=a/b;return c;}//Operateint result(SqStack1 *OPND,SqStack2 *OPTR) //求值{char a=0;char theta;int b,c,number=0;IntInitStack(OPND);CharInitStack(OPTR);CharPush(OPTR,'#');a=getchar();while(a!='#' || CharGetTop(OPTR)!='#'){printf("输入字符：%c ",a);if(!In(a)) //不是运算符则进栈{number=0;while(!In(a)){number = number*10 +(a-48); //处理多位整数z=10*x+ya = getchar();}IntPush(OPND,number);printf("主要操作：Push(OPND,%d) ",number);}elseswitch(Precede(a,CharGetTop(OPTR))){case '<':CharPush(OPTR,a);a=getchar();printf("主要操作：Push(OPTR,%c) ",a);break;case '=':CharPop(OPTR);a=getchar();printf("主要操作：Pop(OPTR,%c) ",a);break;case '>':theta=CharPop(OPTR);c=IntPop(OPND);b=IntPop(OPND);IntPush(OPND,Operate(b,theta,c));printf("主要操作：Operate(%d,%c,%d) ",b,theta,c);break;}printf("OPND栈：%d OPTR 栈：%c\n",IntGetTop(OPND),CharGetTop(OPTR));}printf("The result is %d.\n",IntGetTop(OPND)); //打印输出表达式值return OK;}4.主函数和其他函数的代码void main() //主函数，使用自定义函数完成功能{SqStack1 s1,*OPND;SqStack2 s2,*OPTR;OPND=&s1;OPTR=&s2;printf("Please enter an expression with a end of '#'.\n");printf("The Expression:");result(OPND,OPTR);}char Precede(char a,char b)//运算优先级判断{int i,j;char Table[8][8]={' ','+','-','*','/','(',')','#','+','>','>','<','<','<','>','>','-','>','>','<','<','<','>','>','*','>','>','>','>','<','>','>','/','>','>','>','>','<','>','>','(','<','<','<','<','<','=',' ',')','>','>','>','>',' ','>','>','#','<','<','<','<','<',' ','=',}; //优先级表格for(i=0;i<8;i++)if(Table[0][i]==a) //纵坐标寻找break;for(j=0;j<8;j++) //横坐标寻找if(Table[j][0]==b)break;return Table[j][i];}int In(char c) //判断c是否为操作符{if ( c=='(' || c=='+' || c=='-' || c == '*' || c=='/' || c==')' || c=='#' || c=='^')return 1; //如果是操作符返回1elsereturn 0; //不是，返回0}5．函数的调用关系图反映了演示程序的层次结构：mainresultInitStack Push GetTop In Precede Pop 四、调试分析算术表达式求值程序较为庞大，调试花费时间较多，主要是在for循环和while循环时容易出错，对于涉及的循环的操作开始和结束条件设置很关键。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构中算术表达式地求值演示地源程序有标准答案吗,谢谢50 分标签：求值算术表达式源程序标准答案概要设计回答：2 浏览：2538 提问时间：2005-12-10 18:29这是课程设计,除了源程序, 还要有需求分析,概要设计,详细设计,调试分析,用户手册,测试结果, 心得体会,关键是需求分析, 概要设计,详细设计,调试分析,用户手册不知道应该怎么写b5E2RGbCAP共0 条评论...相关资料: 算术表达式和赋值表达式(1>.swf 更多资料>> 最佳答案此答案由提问者自己选择，并不代表爱问知识人地观点揪错:评论:举报plEanqFDPwkillbig[学者] 算术表达式地源程序#include<stdio.h> #include<stdlib.h> #include<math.h>#define POW 1#define MUL 2#define DIV 3#define ADD 4#define SUB 5#define Lp 6#define Rp 7#define END 8#define Epsilon 1e-7 typedef double NODE 。
struct{char op。
int code 。
}opchTbl[]={{'*'，2}，{'/'，3}，{'+'，4}，{'-'，5}，{'('，6}，DXDiTa9E3d {'>',7},{t1},{'\n',8},{' ',-1}} 。
typedef struct node{NODE data 。
struct node *link 。
}LNODE 。
LNODE *optop , *numtop 。
NONO(char *t,double sum>{int i 。
char str[15] 。
FILE *wf 。
wf=fopen("62346_4.dat","w"> 。
for(i=0 。
i<62 。
i++>{if(*(t+i>!=0 && *(t+i>!=10 && *(t+i>!=13> fprintf(wf,"%c",*(t+i>> 。
}sprintf(str, "=%f\n",sum> 。
for(i=0。
i<14。
i++>if((int>str[i]!=48 && (int>str[i]!=15> fprintf(wf,"%c",str[i]> 。
fclose(wf> 。
}void l_push(NODE x,LNODE * *toppt>{LNODE *p=(LNODE *>malloc(sizeof(LNODE>> p->data=x。
p->link= *toppt 。
*toppt=p 。
}int l_pop(NODE *cp,LNODE * *toppt> {LNODE *p= *toppt 。
if(*toppt==NULL>return 1 。
*cp=p->data。
*toppt=p->link 。
free(p> 。
return 0。
}int osp[]={5,3,3,2,2,5,1,1}, isp[]={4,3,3,2,2,0} 。
void synError(>{ double temp 。
printf("syntax err!"> 。
while(optop!=NULL> l_pop(&temp,&optop> 。
while(numtop!=NULL> l_pop(&temp,&numtop> exit(0> 。
}double eval(char tag,double left, double right>{int n。
double result 。
switch(tag>{case POW : for(n=1,result=left 。
n<right 。
n++> result *=left 。
return result 。
case ADD : return left+right 。
case SUB : return left-right 。
case MUL : return left*right 。
case DIV : if(fabs(right><=Epsilon>{printf("/0 err\n"> 。
exit(1> 。
}return left/right 。
}printf("expression err!/n"> 。
return 1.0。
}int c=' ',k=0 。
int t[61] 。
#define RADIX 10int getToken(double *nump> { double dradix,num 。
int i 。
while(c==' '|| c=='\t'>c=getchar(> 。
if(c<'0' || c>'9'>{for(i=0 。
opchTbl[i].code!=-1 && opchTbl[i].op!=c 。
RTCrpUDGiTi++> 。
if(opchTbl[i].code==-1>synError(> 。
if(c!='\n'>c=getchar(> 。
t[k]=c 。
k++ 。
return opchTbl[i].code 。
} num=0 。
while(c>='0'&&c<='9'>{ num=RADIX *num+c-'0' 。
c=getchar(> 。
t[k]=c 。
k++ 。
}if(c=='.'>{ dradix=1.0/RADIX 。
c=getchar(> 。
t[k]=c 。
k++ 。
while(c>='0'&&c<='9'>{ num=num+(c-'0'>*dradix 。
dradix/=RADIX 。
c=getchar(> 。
t[k]=c 。
k++ 。
}}*nump=num 。
return 0 。
void main(>{double num , dop, operand1,operand2,res。
int type,i 。
char ans,op。
do{printf("input syntax!\n"> 。
optop=numtop=NULL 。
l_push(Lp,&optop> 。
do {c=getchar(> 。
t[k]=c 。
k++ 。
}while(c==' ' || c=='\n' || c=='\t'> 。
while(1>{type=getToken(&num> 。
if(type==0>l_push(num,&numtop> 。
else{ if(osp[type-1]>isp[(int>optop->data-1]> l_push((double>type,&optop> 。
else{ while(osp[type-1]<=isp[(int>optop->data-1] && optop->data<=5>{ if(l_pop(&dop,&optop>>synError(> 。
op=(char>dop 。
if(l_pop(&operand2,&numtop>> synError(> 。
if(l_pop(&operand1,&numtop>> synError(> 。
res=eval(op,operand1,operand2>。
l_push(res,&numtop> 。
}if(type==END>break 。
if(type==Rp>{ do if(l_pop(&dop,&optop>> synError(> 。
while((char>dop!=Lp> 。
}else l_push((double>type,&optop> 。
}} if(l_pop(&operand1,&numtop>>synError(> 。
while(optop!=NULL> l_pop(&dop,&optop> 。
printf("result=%f\n",operand1> 。
printf("continue ?(Y>"> 。
scanf("%c",&ans> 。
}while(ans=='y' || ans=='Y'> 。
NONO(t,operand1> 。
for(i=0。
i<61。
i++>printf("%c",t[i]> 。
}QQ16806008回答：2005-12-10 18:34提问者对答案地评价：两个答案都太有水平了,第二个源程序更是超出大部分初学者地水平了共0 条评论... 以下是特别推荐给您地相关问题学软件开发需要学那些课程还有,关于3G 手机软件开发,都有一些什么样地课程... 5分求复杂表达式地值1 0分我看现在关于软件开发地培训机构好像挺多地，可是为…10分已知Y=F<X )是定义域在R上地偶函数，治疗乳腺增生- 很轻松治疗乳房肿块、乳腺增生,一次性治愈不复发新浪爱问共享资料- 存储安全长久数百万中文资料免费共享，高速上传下载爱问机器人--解决所有难题会自动回复地高智商微博机器人，试一试5PCzVD7HxA其它回答共1条回答评论:举报祥子[学者] 算术表达式求值演示一. 需求分析1.要求应用栈来实现表达式地分析计算( 用运算符优先法>.2.以字符序列地形式从终端输入语法正确地表达式( 本程序可以输入浮点数作运算数>.3.演示程序以计算器地仿真界面实现与用户间地对话. 当用户从终端输入某一字符时，仿真界面上地相应字符按钮会变黑( 表示按下>.4.程序地实现效果在附交地软盘中. 请运行程序观看.二.调试分析1.由于考虑不周，本程序快要完成时才发现由于函数调用太深，无法处理好局部变量，只好用了两个全局变量start_x 和start_y( 有违初衷>，它们指定CALCULATOR 地绘制jLBHrnAILg2.由于库函数getchar(>和getch(>地微妙地差别，使得绘图部份功能一度陷入混乱最后才得以调整.3.本程序地模块性有待加强.三.用户手册1.本程序在TURBO C2.0 下运行良好. 源程序文件为Evaluate.c.2.进入演示程序后，显示图像编程模拟地计算器仿真界面，按键盘上地键位以达相应地视觉效果.3.注意: 请不要输入错误地表达式, 确定表达式只输入一次并且正确( 还要求输入过程中不可以用退格符>, 否则会产生莫明其妙地错误结果.4.本程序扩充了运算符集, 支持乘方运算符" p ", 例如输入: 5p2+5p2# 则结果为50.000000支持平方运算符” A",例如输入：5A+5A#则结果为50.000000支持单目减运算符" ~ ", 例如输入: ~4+4# 则结果为0.000000 支持实数类型作运算量类型, 例如输入： 3.14+3.14# 则结果为6.280000 实现了计算器地仿真界面, 如运行效果所视.5.附：赋值运算符和支持变量参与运算地功能尚未加入.四.测试结果具体请观看软盘中地源程序执行地效果.五. 附录源程序主要文件清单：附件：Evaluate.c。