您的位置：360文档中心› 算术表达式求值源代码

算术表达式求值源代码

合集下载

算术表达式求值

算术表达式求值

#include <stdio.h>#include <math.h>#include <malloc.h>#include <errno.h>#include <stdlib.h>#include <string.h>#define DEBUG#define ERROR -1#define STACKSIZE 20/* 定义字符类型栈*/typedef struct{char stackname[20];char *base;//栈底指针char *top; //栈顶指针} Stack;/* ----------------- 全局变量--------------- */ Stack OPTR, OPND; /* 定义前个运算符栈，后个操作数栈*/char expr[255]; /* 存放表达式串*/char *ptr = expr;int step = 0; /* 计算的步次*//*构造一个空栈*/int InitStack(Stack *s, char *name){s->base=(char*)malloc(STACKSIZE*sizeof(char));if(!s->base) exit (ERROR);strcpy(s->stackname, name);s->top=s->base;return 1;}/*定义四则运算符*/int In(char ch){return(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('| |ch==')'||ch=='#');}/*输出相关变量的值*/void OutputStatus( ){char *s;/* step */printf("\n%-8d", ++step); /* OPTR */for(s = OPTR.base; s < OPTR.top; s++) printf("%c", *s);printf("\t");/* OPND */for(s = OPND.base; s < OPND.top; s++) printf("%d ", *s);/* input char */printf("\t\t%c", *ptr);}/*插入*/int Push(Stack *s,char ch){#ifdef DEBUGchar *name = s->stackname;OutputStatus();if(strcmp(name, "OPND") == 0)printf("\tPUSH(%s, %d)", name, ch);elseprintf("\tPUSH(%s, %c)", name, ch);#endif*s->top=ch;s->top++;return 0;}/*删除*/char Pop(Stack *s){char p;#ifdef DEBUGOutputStatus();printf("\tPOP(%s)", s->stackname);#endifs->top--;p=*s->top;return (p);}char GetTop(Stack s){char p=*(s.top-1);return (p);}/* 判断运算符优先权，返回优先权高的*/char Precede(char c1,char c2){int i=0,j=0;static char array[49]={'>', '>', '<', '<', '<', '>', '>','>', '>', '<', '<', '<', '>', '>','>', '>', '>', '>', '<', '>', '>','>', '>', '>', '>', '<', '>', '>','<', '<', '<', '<', '<', '=', '!','>', '>', '>', '>', '!', '>', '>','<', '<', '<', '<', '<', '!', '='};switch(c1){/* i为下面array的横标*/case '+' : i=0;break;case '-' : i=1;break;case '*' : i=2;break;case '/' : i=3;break;case '(' : i=4;break;case ')' : i=5;break;case '#' : i=6;break;}switch(c2){/* j为下面array的纵标*/case '+' : j=0;break;case '-' : j=1;break;case '*' : j=2;break;case '/' : j=3;break;case '(' : j=4;break;case ')' : j=5;break;case '#' : j=6;break;}return (array[7*i+j]); /* 返回运算符*/}/*操作函数*/int Operate(int a,char op,int b){#ifdef DEBUGOutputStatus();printf("\tOPERATE(%d, %c, %d)", a, op, b); #endifswitch(op){ case '+' : return (a+b);case '-' : return (a-b);case '*' : return (a*b);case '/' : return (a/b);}}int EvalExpr( ){char c,theta,x,m,ch;int a,b;c = *ptr++;while(c!='#'||GetTop(OPTR)!='#'){if(!In(c)){m=atoi(&c);Push(&OPND,m);c = *ptr++;}elseswitch(Precede(GetTop(OPTR),c)){case '<':Push(&OPTR,c);c = *ptr++;break;case '=':x=Pop(&OPTR);c = *ptr++;break;case '>':theta=Pop(&OPTR);b=Pop(&OPND); a=Pop(&OPND);Push(&OPND,Operate(a,theta,b));break;}}return GetTop(OPND);}main( ){printf("Input the expression(end with \"#\" sign):");do{gets(expr);}while(!*expr);InitStack(&OPTR, "OPTR"); /* 初始化运算符栈*/Push(&OPTR,'#'); /* 将#压入运算符栈*/ InitStack(&OPND, "OPND"); /* 初始化操作数栈*/printf("\n\nresult:%d\n", EvalExpr());//return;}第二个作者：麻英圳学号：20031302202算法思想：具体做法是设两个栈，一个是操作数栈opnd，另一个是运算符栈oprt，分别存放操作数与运算符。

算术表达式

算术表达式

1，实验名称：算术表达式2，实验程序源代码如下：#include<stdio.h>#include<string.h>#include<stdlib.h>#include<malloc.h>#define MAXNUM 100typedefstruct{char data[MAXNUM];int top;}SeqStack;SeqStack *SetNull(){SeqStack *s;s=(SeqStack*)malloc(sizeof(SeqStack));s->top=-1;return s;}bool Empty(SeqStack *s){return (s->top<0?true:false);}bool push(SeqStack *s,char x){if(s->top==MAXNUM-1){printf("FULL OUT!\n");returnfalse;}else{s->top=s->top+1;s->data[s->top]=x;returntrue;}}bool pop(SeqStack *s,char *x){if(s->top==-1){printf("FULL OUT!\n");returnfalse;}else{*x=s->data[s->top];s->top--;returntrue;}}char gettop(SeqStack *s){if(s->top==-1){printf("FULL OUT!\n");returnfalse;}elsereturn (s->data[s->top]);}bool isfull(SeqStack *s){return (s->top==MAXNUM-1?true:false);}typedefstruct{int data[MAXNUM];int top;}SeqStack1;SeqStack1 *SetNull1(){SeqStack1 *s;s=(SeqStack1*)malloc(sizeof(SeqStack1));s->top=-1;return s;}bool Empty1(SeqStack1 *s){return (s->top<0?true:false);}bool push1(SeqStack1 *s,int x){if(s->top==MAXNUM-1){printf("FULL OUT!\n");returnfalse;}else{s->top=s->top+1;s->data[s->top]=x;returntrue;}}bool pop1(SeqStack1 *s,int x){if(s->top==-1){printf("FULL OUT!\n");returnfalse;}else{x=s->data[s->top];s->top--;returntrue;}}int gettop1(SeqStack1 *s){if(s->top==-1){printf("FULL OUT!\n");returnfalse;}elsereturn (s->data[s->top]);}bool isfull1(SeqStack1 *s){return (s->top==MAXNUM-1?true:false); }bool fixtosuffix(char *infix,char *suffix) {bool state=false;char c,c2;int i,j=0;SeqStack *ps;ps=SetNull();if(infix[0]=='\0')returnfalse;for(i=0;infix[i]!='\0';i++){c=infix[i];switch(c){case' ':case'\t':case'\n': if(state==true)suffix[j++]=' ';state=false;break;case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9': state=true;suffix[j++]=c;break;case'(': if(state==true)suffix[j++]=' ';state=false;push(ps,c);break;case')': if(state==true)suffix[j++]=' ';state=false;c2=')';while(!Empty(ps)){c2=gettop(ps);pop(ps,&c2);if(c2=='(')break;suffix[j++]=c2;}if(c2!='('){free(ps);suffix[j++]='\0';returnfalse;}break;case'+':case'-': if(state==true)suffix[j++]=' ';state=false;while(!Empty(ps)){c2=gettop(ps);if(c2=='+'||c2=='-'||c2=='*'||c2=='/'){pop(ps,&c2);suffix[j++]=c2;}elseif(c2=='(')break;}push(ps,c);break;case'*':case'/': if(state==true)suffix[j++]=' ';state=false;while(!Empty(ps)){c2=gettop(ps);if(c2=='*'||c2=='/'){pop(ps,&c2);suffix[j++]=c2;}elseif(c2=='+'||c2=='-'||c2=='(')break;}push(ps,c);break;default:free(ps);suffix[j++]='\0';returnfalse;}}if(state==true)suffix[j++]=' ';while(!Empty(ps)){c2=gettop(ps);pop(ps,&c2);if(c2=='('){free(ps);suffix[j++]='\0';returnfalse;}suffix[j++]=c2;}free(ps);suffix[j++]='\0';returntrue;}int Calculatesuffix(char *suffix){bool state=false;int num,num1,num2,presult;int i;char c;SeqStack1 *ps;ps=SetNull1();for(i=0;suffix[i]!='\0';i++){c=suffix[i];switch(c){case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':if(state==true)num=num*10+c-'0';elsenum=c-'0';state=true;break;case' ':case'\t':case'\n':if(state==true){push1(ps,num);state=false;}break;case'+':case'-':case'*':case'/':if(state==true){push1(ps,num);state=false;}if(Empty1(ps)){free(ps);return 0;}num2=gettop1(ps);pop1(ps,num2);if(Empty1(ps)){free(ps);return 0;}num1=gettop1(ps);pop1(ps,num1);if(c=='+')push1(ps,num1+num2);if(c=='-')push1(ps,num1-num2);if(c=='*')push1(ps,num1*num2);if(c=='/')push1(ps,num1/num2);break;default:free(ps);return 0;}}presult=gettop1(ps);pop1(ps,presult);if(!Empty1(ps)){free(ps);return 0;}free(ps);return presult;}int main(){char c,infix[MAXNUM],suffix[MAXNUM];int result=0;bool flag=true;while(flag==true){printf("GET LINE!\n");gets(infix);if(fixtosuffix(infix,suffix)==true)printf("The suffix is:%s\n",suffix);else{printf("The infix is no use!\n");printf("\n Continue? (y/n)");scanf("%c",&c);if(c=='n'||c=='N')flag=false;while(getchar()!='\n');printf("\n");continue;}result=Calculatesuffix(suffix);if(Calculatesuffix(suffix))printf("The fix is:%d\n",result);elseprintf("The fix is no use!\n");printf("\n Continue? (y/n)");scanf("%c",&c);if(c=='n'||c=='N')flag=false;while(getchar()!='\n');printf("\n");}return 0;}3，运行结果如下：计算（5+8）*2的值，并将中缀表达式以后缀表达式形式输出为5 8 + 2 *。

算术表达式的计算c语言代码

算术表达式的计算c语言代码

算术表达式的计算c语言代码算术表达式是计算机程序中最基础的计算方式之一。

在C语言中，我们可以使用算术表达式的计算c语言代码来实现各种算术运算。

本文将介绍算术表达式的计算c语言代码的基本语法和使用方法。

基本语法在C语言中，算术表达式的计算c语言代码的基本语法如下：```#include <stdio.h>int main(){//定义变量int a = 10, b = 20, c;//加法运算c = a + b;printf("a+b=%d\n", c);//减法运算c = a - b;printf("a-b=%d\n", c);//乘法运算c = a * b;printf("a*b=%d\n", c);//除法运算c = a / b;printf("a/b=%d\n", c);//取模运算c = a % b;printf("a%%b=%d\n", c);return 0;}```在这段代码中，我们通过定义变量来实现算术表达式的计算。

通过加、减、乘、除、取模等运算符来实现各种算术运算。

其中，printf 函数用于输出结果。

使用方法使用算术表达式的计算c语言代码的方法如下：1. 定义变量首先需要定义变量，以存储计算结果。

在C语言中，变量需要声明其类型，例如 int、float、double等。

2. 进行算术运算使用加、减、乘、除、取模等运算符进行算术运算。

需要注意的是，除法运算符/返回的是商，取模运算符%返回的是余数。

3. 输出结果使用printf函数输出运算结果。

总结算术表达式的计算c语言代码是C语言中最基础的计算方式之一。

通过定义变量、进行算术运算、输出结果等步骤来实现。

需要注意运算符的优先级和方向，以免出现错误结果。

在程序中应该尽可能使用注释来解释代码的含义和作用，以方便自己和他人的理解和修改。

算术表达式求值数据结构代码

算术表达式求值数据结构代码

#include <iostream>#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<string.h>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2#define STACK_SIZE 100#define STACKINCREMENT 10#define OPSIZE 7typedef double ElemType;typedef char SElemType;char op[OPSIZE]={'+','-','*','/','(',')','#'};charprior[OPSIZE][OPSIZE]={{'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','>','>','<','>','>'},{'>','>',' >','>','<','>','>'},{'<','<','<','<','<','=',' '},{'>','>','>','>',' ','>','>'},{'<','<','<','<','<',' ','='}};typedef struct {ElemType *top;ElemType *base;int Stacksize;}OPND;typedef struct {SElemType *top;SElemType *base;int Stacksize;}OPTR;void InitStack(OPND *S1){S1->base=(ElemType *)malloc(STACK_SIZE * sizeof(ElemType));if(NULL==S1->base){printf("Init Failed!\n");exit (OVERFLOW);}else{S1->top=S1->base;S1->Stacksize=STACK_SIZE;}}int StackEmpty(OPND *S1){if(S1->top==S1->base)return 1;elsereturn 0;}int StackEmpty(OPTR *S2){if(S2->top==S2->base)return 1;elsereturn 0;}void InitStack(OPTR *S2){S2->base=(SElemType *)malloc(STACK_SIZE*sizeof(SElemType));if(NULL==S2->base){printf("Init Failed!\n");exit (OVERFLOW);}else{S2->top=S2->base;S2->Stacksize=STACK_SIZE;}}void Push(OPND *S1,ElemType e){if(S1->top-S1->base>=S1->Stacksize){S1->base=(ElemType*)realloc(S1->base,(S1->Stacksize+STACKINCREMENT)*sizeof(ElemType));if(!S1->base)exit(OVERFLOW);S1->top=S1->base+S1->Stacksize;S1->Stacksize=S1->Stacksize+STACKINCREMENT;}*S1->top=e;S1->top++;}void Push(OPTR *S2,SElemType e){if(S2->top-S2->base>=S2->Stacksize){S2->base=(SElemType*)realloc(S2->base,(S2->Stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S2->base)exit (OVERFLOW);S2->top=S2->base+S2->Stacksize;S2->Stacksize+=STACKINCREMENT;}*S2->top++=e;}ElemType Pop(OPND *S1,ElemType *e){if(!StackEmpty(S1)){S1->top=S1->top-1;*e=*S1->top;}else{return ERROR;}return OK;}SElemType Pop(OPTR *S2,SElemType *e){if(StackEmpty(S2)){return ERROR;}else{*e=*--S2->top;}return OK;}ElemType GetTop(OPND *S1,ElemType *e){if(!StackEmpty(S1)){*e=*(S1->top-1);}return OK;}SElemType GetTop(OPTR *S2,SElemType *e){if(!StackEmpty(S2)){*e=*(S2->top-1);}return OK;}bool Judege(char c,char *op)//判断C是否为运算符{bool check=false;int i;for(i=0;i<OPSIZE;i++){if(c==op[i]){check = true;}}return check;}int ReturnOpOrd(char c,char *op)//返回运算符c在OP中的位置{int i;for(i=0;i<OPSIZE;i++){if(c==op[i]){return i;}}return OK;}char Precede(char theat1,char theat2)//g判断运算符栈的栈顶运算符theta1和读入的运算符theta2优先关系{return prior[ReturnOpOrd(theat1,op)][ReturnOpOrd(theat2,op)];}double Operate(ElemType a,SElemType theat,ElemType b)//操作数进行运算{switch(theat){case '+':return a+b;break;case '-':return a-b;break;case '*':return a*b;break;case '/':if(b!=0){return a/b;}else{printf("出错！除数为0！\n");return ERROR;}break;default:return 0;}}float EvaluateExpression(char *expression){OPND S1;OPTR S2;char *c=expression;ElemType e1,e2,result,d;char temp[10],r[2];SElemType e;InitStack(&S1);InitStack(&S2);Push(&S2,'#');strcpy(temp,"\0");while(*c!='#'||((GetTop(&S2,&e),e))!='#'){if(!Judege(*c,op)){r[0]=*c;r[1]='\0';strcat(temp,r);c++;if(Judege(*c,op)){d=(float)atof(temp);Push(&S1,d);strcpy(temp,"\0");}}else{switch(Precede( (GetTop(&S2,&e),e),*c)){case '<':Push(&S2,*c);c++;break;case '=':Pop(&S2,&e);c++;break;case '>':Pop(&S1,&e1);Pop(&S1,&e2);Pop(&S2,&e);result=Operate(e2,e,e1);Push(&S1,result);break;}}}Pop(&S1,&result);return result;}int main(){char expression[80];float result;printf("输入你要计算的算式：\n");gets(expression);result=EvaluateExpression(expression);printf("计算结果为：%f",result);return OK;}。

数据结构-算术表达式求值(含需求分析和源代码)

数据结构-算术表达式求值(含需求分析和源代码)

需求分析(附代码)一、需求分析（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已存在。

数据结构课程设计算术表达式求值-计算器(Word)

数据结构课程设计算术表达式求值-计算器(Word)

高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值，并打印求值过程中运算符栈、操作数栈的变化过程。

第二章系统分析开始运行时界面如下：你可以输入一个表达式，按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，退出系统。

算术表达式求值源代码

算术表达式求值源代码

#include<stdio.h>#include<conio.h>#include<stdlib.h>#define FALSE 0#define TRUE 1#define MAXSIZE 100 /*存储空间初始分配量*/#define N 10 /*存储空间增加量*/#define NULL 0typedef struct StStack{float *base; /*在栈构造之前和销毁之后，base的值为0*/float *top; /*栈顶指针*/int size; /*当前已分配的存储空间，以元素为单位*/}StStack;typedef struct StStack_c{char *base;char *top;int size;}StStack_c;void InitStack(StStack *S){/*构造一个空栈S存储数据*/S->base=(float *)malloc(MAXSIZE*sizeof(float));if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base;S->size=MAXSIZE;}void InitStack_c(StStack_c *S){/*构造一个空栈S存储符号；*/S->base=(char *)malloc(MAXSIZE*sizeof(char));if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base;S->size=MAXSIZE;}void Push(StStack *S,float e){/*插入元素e为新的栈顶元素*/if(S->top==S->base+S->size){ S->base=(float *)realloc(S->base,(S->size+N)*sizeof(float)); /*若栈满则增存储空间*/if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base+S->size; /*增加存储空间*/S->size+=N;}S->base[(S->top++)-S->base]=e;}void Push_c(StStack_c *S,char ch){/*插入元素ch为新的栈顶元素*/if(S->top==S->base+S->size){ S->base=(char *)realloc(S->base,(S->size+N)*sizeof(char)); /*若栈满则增存储空间*/if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base+S->size;S->size+=N;}S->base[(S->top++)-S->base]=ch;}void Pop(StStack *S,float *e){/*若栈不空，则删除S的栈顶元素，用e返回其值*/if(S->top!=S->base)*e=S->base[(S->top--)-S->base-1];}void Pop_c(StStack_c *S,char *ch){/*若栈不空，则删除S的栈顶元素，用ch返回其值*/if(S->top!=S->base)*ch=S->base[(S->top--)-S->base-1];}float GetTop(StStack *S){/*若栈不空，则用e返回S的栈顶元素*/int n; /*存放栈顶元素的位置*/float e;if(S->top!=S->base){n=S->top-S->base-1;e=S->base[n];return e; /*返回S的栈顶元素*/}}char GetTop_c(StStack_c *S){/*若栈不空，则用ch返回S的栈顶元素*/int n;char ch;if(S->top!=S->base){n=S->top-S->base-1;ch=S->base[n];return ch;}}int In_c(char ch){/*判断是否为运算符，是则返回TRUE，否则返回FALSE*/if(ch=='+'||ch=='-') return TRUE;else if(ch=='*'||ch=='/') return TRUE;else if(ch=='('||ch==')') return TRUE;else if(ch=='#') return TRUE;else return FALSE;}int check_ch(char *ch){/*判断输入是否符合表达式的要求*/while(*ch!='#'){if(*ch=='.'||*ch>='0'&&*ch<='9'||In_c(*ch)) /*表达式的限制条件*/{if(*ch>='0'&&*ch<='9') {ch++;continue;}if(*ch=='.') /*小数点前后不是数字的处理*/{if(In_c(*(++ch))) return FALSE;else ch--;if(In_c(*(--ch))) return FALSE;else ch++;}/*if-2*/else{if(In_c(*(++ch))&&In_c(*(--ch))) /*相邻的两运算符的处理*/{if(*(++ch)=='(') continue; /*在'('前的运算符情况处理*/else ch--;if(*(++ch)=='-'&&*(--ch)=='(') {ch++; continue;} /*()内第一位数为负的运算符处理*/else ch--;if(*(++ch)!='#'&&*(--ch)==')') {ch++; continue;} /*在')'后的运算符情况处理*/else if(*ch--!='#') return FALSE;}/*if-3*/else ch--;}/*if-else2*/ch++;}/*if-1*/else return FALSE;}/*while*/if(*ch=='#') return TRUE;}float operate(float x,char c,float y){/*基本运算的实现*/switch(c){case '+': return x+y;case '-': return x-y;case '*': return x*y;case '/': if(y!=0) return x/y; /*被除数不为0*/ else{printf("\nThe divisor is 0,can't permit !\n");exit(1);}}}char Precede(char x,char y){/*运算符的优先权*/switch(x){case '+': if(y=='*'||y=='/'||y=='(') return '<';else return '>';case '-': if(y=='*'||y=='/'||y=='(') return '<';else return '>';case '*': if(y=='(') return '<';else return '>';case '/': if(y=='(') return '<';else return '>';case '(': if(y==')') return '=';else return '<';case ')': if(y!='(') return '>';case '#': if(y=='#') return '=';else if(y!=')') return '<';}}int changeN(StStack *S,char *ch){/*将字符转换为数值*/int j,h,k=0;float m,n=0;char c;while(*ch>='0'&&*ch<='9'||*ch=='.'){n=n*10+(*ch-48); /*将字符转换为数值存入n中*/k++; /*k记录数值的位数*/ch++;if(*ch=='.') /*若有小数，将n,k存入m,h，并初始化方便小数的转换*/ {m=n;n=0;h=k;k=0;c=*ch;ch++; /*将'.'存入c,对下一个字符进行操作*/}if(c=='.'&&In_c(*ch)==TRUE) /*对小数部分的处理*/{for(j=0;j<k;j++)n=n/10;n+=m;k=++k+h;}}/*while*/Push(S,n); /*将转换好的数值入栈*/return k; /*返回数值的位数*/}int DealNeg(StStack *S,char *ch){/*对括号内负数的处理*/int k=0,i=0;float e,n=0;if(*(--ch)=='('&&*(++ch)=='-'){k=changeN(S,++ch);Pop(S,&e);n=-1*e;Push(S,n);return k;}else return FALSE;}void Operating(char *c,StStack *OPND,StStack_c *OPTR)/*表达式运算过程*/{char ch;int k=0,i=0;float a,b,e;if(c[0]=='-'&&(!In_c(c[1]))) /*判断首数是负数则进栈*/{k=changeN(OPND,&c[1]);i+=k+1; /*首数是负数保存其位数*/Pop(OPND,&e);e=-1*e; /*保存负数*/Push(OPND,e);}do{if(!In_c(c[i])) /*不是运算符则转换为数值并进栈*/{k=changeN(OPND,&c[i]);i+=k-1; /*下一个字符在串中的下标*/}else{if(k=DealNeg(OPND,&c[i])) i+=k; /*判断是负数则进栈*/else{switch(Precede(GetTop_c(OPTR),c[i])){case '<': Push_c(OPTR,c[i]); /*栈顶元素优先权低*/ break;case '=': Pop_c(OPTR,&ch); /*脱括号并接收下一字符*/ break;case '>': Pop_c(OPTR,&ch); /*退栈并将输出结果入栈*/ Pop(OPND,&b);Pop(OPND,&a);e=operate(a,ch,b); /*将运算结果存入e中*/if(GetTop_c(OPTR)=='-') /*若结果前为'-'则取其相反数*/{Pop_c(OPTR,&ch);Push_c(OPTR,'+');e=-1*e;}Push(OPND,e);if(c[i]!='#'&&c[i]!=')') /*当前符号不是'#'则入栈*/ Push_c(OPTR,c[i]);else i--;}/*switch()*/}/*if-else-1*/}/*if-else-2*/i++;}while(GetTop_c(OPTR)!='#'||c[i]!='#'); /*判断表达式是否结束*/}void main(){char str[40 ],*c,ch;float i=0,n,f;FILE *fp;StStack s1,*OPND; /*定义关于数值的栈*/StStack_c s2,*OPTR; /*定义关于字符的栈*/OPND=&s1;OPTR=&s2;clrscr();c=str;if((fp=fopen("date.txt","w"))==NULL) /*打开文档并将正确的表达式和结果写入文档*/{printf("can't open the file.\n");i=1;} /*出错提示*/do{InitStack_c(OPTR);Push_c(OPTR,'#');InitStack(OPND);do{printf("\nPlease input the expression: ");scanf("%s",c);getchar();if(check_ch(c)) f=1;else{printf("\nWarning: the expression you input is non-standard!!\n");f=0;}}while(f!=1); /*表达式若不符合要求则重新输入*/Operating(c,OPND,OPTR);n=GetTop(OPND);printf("\nThe result of the expression is: %.2f.\n",n);if(i!=1) /*将表达式和结果写入文档*/{fputs("\nThe expression is: \0",fp);fputs(c,fp);fputs("\nThe result is: \0",fp);fprintf(fp,"%.2f",n);}printf("\nDo you want to calculate the next expression(y/n): ");ch=getchar(); getchar();}while(ch=='y'||ch=='Y');fclose(fp); /*关闭文件*/}。

表达式求值 编程代码

表达式求值 编程代码

#include<iostream>#include<conio.h>#include<stdlib.h>#include<stack>using namespace std;#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define INFEASIBLE -1 charPercede(char a,char b) {switch(a){case '+':case '-':{switch(b){case '+':case '-':case ')':case '#':return '>';default:return '<';}}case '*':case '/':{switch(b){case '(':return '<';default:return '>';}}case '(':{switch(b){case ')':return '=';default:return '<';}}case ')': return '>';case '#':{switch(b){case '#':return '=';default:return '<';}}default: exit(0);}}bool In(char a){if(a=='+'||a=='-'||a=='*'||a=='/'||a=='('||a==')'||a=='#')return true;else return false;}int Operate(inta,chartheta,int b){if(!In(theta)) exit(0);switch(theta){case '+':return a+b;case '-':return a-b;case '*':return a*b;case '/':return a/b;default:exit(0);}}voidEvaluateExpression(){chartheta,c; inta,b,temp,flag=0;stack<char> OPTR;stack<int> OPND;OPTR.push('#');cout<<"ÊäÈëÒªÇóÖµµÄ±í´ïʽ(ÒÔ'#'½áβ):";cin>>c;while(c!='#'||OPTR.top()!='#'){if(!In(c)){if(flag==0) { flag=1;OPND.push((int)(c-'0'));cin>>c;}else if(flag==1) { temp=OPND.top();OPND.pop(); OPND.push(10*temp+(int)(c-'0'));cin>>c;}}else if(In(c)){flag=0;switch(Percede(OPTR.top(),c)){case '<':{OPTR.push(c);cin>>c;break;}case '=':{OPTR.pop();cin>>c;break;}case '>':{theta=OPTR.top();OPTR.pop();a=OPND.top();OPND.pop();b=OPND.top();OPND.p op();OPND.push(Operate(b,theta,a));break;}}}}cout<<"\n±í´ïʽֵΪ£º"<<OPND.top()<<endl;}void main(){EvaluateExpression();}。

算术表达式求值

算术表达式求值

算术表达式求值 表达式求值是实现程序设计语⾔的基本问题之⼀，也是栈的应⽤的⼀个典型例⼦。

设计⼀个程序，演⽰⽤算符优先法对算术表达式求值的过程 (1)从键盘输⼊任意⼀个语法正确的（中缀）表达式，显⽰并保存该表达式。

(2)利⽤栈结构，把上述（中缀）表达式转换成后缀表达式，并显⽰栈的状态变化过程和所得到的后缀表达式。

(3)利⽤栈结构，对上述后缀表达式进⾏求值，并显⽰栈的状态变化过程和最终结果。

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>#define N 100#define M 10char suffix[N]; //后缀表达式char ret[2]; //字符串栈进⾏弹出时的返回值（弹出元素）char tokens[N][M]; //令牌，将中缀表达式分解后的字符串数组char ctokens[N][M]; //令牌，将后缀表达式分解后的字符串数组int count; //tokens令牌的个数int value; //表达式的值int l = 0; //ctokens令牌的个数typedef struct stack1{ //操作符栈int top;char elem[N][2];}stacki;typedef struct stack2{ //操作数栈int top;int elem[N];}stackj;typedef stacki* STACK; //指向操作符栈的指针typedef stackj* DSTACK; //指向操作数栈的指针void toSuffix(char *str); //将中缀表达式转化成后缀表达式int PreParse(char tokens[][M],char *str); //将中缀表达式分解成令牌返回令牌中字符串个数int GetProsity(char *ch); //获得操作符的优先级并返回void push(STACK S,char *opt); //操作符栈的⼊栈char *pop(STACK S); //操作符栈的出栈，并返回出栈元素int IsEmpty(STACK S); //判断操作符栈是否为空void MakeNull(STACK S); //将操作符栈制空void PrintStack(STACK S); //打印操作符栈void dpush(DSTACK S,int opd); //操作符数的⼊栈void dpop(DSTACK S); //操作符数的出栈void PrintStack1(DSTACK S); //打印操作数栈void MakeNull1(DSTACK S); //将操作数栈制空int Evalute(char ctokens[][M]); //计算后缀表达式的值并返回int main(){char str[N];printf("Please input a expression：\n");gets(str); //输⼊所求中缀表达式strtoSuffix(str); //将中缀表达式转化成后缀表达式puts(suffix); //输出转化后的后缀表达式value = Evalute(ctokens); //计算后缀表达式的值printf("%d",value);return0;}void toSuffix(char *str){int i;stacki stacks; //定义⼀个操作符栈stacksSTACK optstack = &stacks; //定义操作符栈指针optstackMakeNull(optstack);count = PreParse(tokens,str);for(i = 0;i < count;i++){if(!(strcmp(tokens[i],"+") && strcmp(tokens[i],"-") && strcmp(tokens[i],"*") && strcmp(tokens[i],"/") && strcmp(tokens[i],"(") && strcmp(tokens[i],")"))){if(IsEmpty(optstack)){push(optstack,tokens[i]);PrintStack(optstack);}else{if(!strcmp(tokens[i],"(")){push(optstack,tokens[i]);PrintStack(optstack);}else if(!strcmp(tokens[i],")")){while(strcmp(optstack->elem[optstack->top],"(")) //循环直到遇见左括号{strcpy(ctokens[l],optstack->elem[optstack->top]);l++;strcat(suffix,pop(optstack));PrintStack(optstack);}pop(optstack); //左括号弹出PrintStack(optstack);}else{if(GetProsity(tokens[i]) > GetProsity(optstack->elem[optstack->top])){push(optstack,tokens[i]);PrintStack(optstack);}else{while(optstack->top < 100){if(GetProsity(tokens[i]) <= GetProsity(optstack->elem[optstack->top])){strcpy(ctokens[l],optstack->elem[optstack->top]);l++;strcat(suffix,pop(optstack));PrintStack(optstack);}else{break;}}push(optstack,tokens[i]);PrintStack(optstack);}}}}else//是数字则直接加到suffix的后⾯{strcpy(ctokens[l],tokens[i]);l++;strcat(suffix,tokens[i]);}}while(optstack->top < 100) //将剩余元素弹出{strcpy(ctokens[l],optstack->elem[optstack->top]);l++;strcat(suffix,pop(optstack));}PrintStack(optstack);}int PreParse(char tokens[][M],char *str){char p[N];char temp[2];int i=0,j = 0,l,k = 0;for(i = 0;i < strlen(str);i++) //删除表达式中的空格{if(str[i] == '') continue;else{p[j] = str[i];j++;}}p[j] = '\0';i = 0;for(j = 0;j < strlen(p);j++){if(p[j] == '+' || p[j] == '-' || p[j] == '*' || p[j] == '/' || p[j] == '(' || p[j] == ')') //运算符转化为字符串 {temp[0] = p[j];temp[1] = '\0';strcpy(tokens[k],temp);}else{for(l = 0;isdigit(p[j]);l++) //得到多位数字的字符串 {tokens[k][l] = p[j];j++;}tokens[k][l] = '\0';j--;}k++;}return k ;}int GetProsity(char *ch){int prosity;if(!(strcmp(ch,"("))){prosity = 0;}if(!(strcmp(ch,"+") && strcmp(ch,"-"))){prosity = 1;}if(!(strcmp(ch,"*") && strcmp(ch,"/"))){prosity = 2;}return prosity;}void push(STACK S,char *opt){if(S->top == 0){return ;}S->top--;strcpy(S->elem[S->top],opt);return ;}char *pop(STACK S){strcpy(ret,S->elem[S->top]);S->top++;return ret;}int IsEmpty(STACK S){if(S->top > N - 1)return1;elsereturn0;}void MakeNull(STACK S){S->top = N ;}void MakeNull1(DSTACK S){S->top = N ;}void PrintStack(STACK S){int i;for(i = N-1;i >= S->top;i--){printf("%s",S->elem[i]);}printf("\n");}void dpush(DSTACK S,int opd){if(S->top == 0){return ;}S->top--;S->elem[S->top] = opd;}void dpop(DSTACK S){S->top++;}void PrintStack1(DSTACK S){int i;for(i = N-1;i >= S->top;i--){printf("%d ",S->elem[i]);}printf("\n");}int Evalute(char ctokens[][M]){int i;int ropd,lopd;int t;stackj stack; //定义⼀个操作数栈DSTACK opdstack = &stack; //初始化操作数栈指针MakeNull1(opdstack);for(i = 0;i < l;i++){if(!strcmp(ctokens[i],"+")) //操作符则弹出两栈内元素进⾏相应运算 {ropd = opdstack->elem[opdstack->top];dpop(opdstack);lopd = opdstack->elem[opdstack->top];dpop(opdstack);t = lopd + ropd;dpush(opdstack,t);PrintStack1(opdstack);}else if(!strcmp(ctokens[i],"-")){ropd = opdstack->elem[opdstack->top];dpop(opdstack);lopd = opdstack->elem[opdstack->top];dpop(opdstack);t = lopd - ropd;dpush(opdstack,t);PrintStack1(opdstack);}else if(!strcmp(ctokens[i],"*")){ropd = opdstack->elem[opdstack->top];dpop(opdstack);lopd = opdstack->elem[opdstack->top];dpop(opdstack);t = lopd * ropd;dpush(opdstack,t);PrintStack1(opdstack);}else if(!strcmp(ctokens[i],"/")){ropd = opdstack->elem[opdstack->top];dpop(opdstack);lopd = opdstack->elem[opdstack->top];dpop(opdstack);t = lopd / ropd;dpush(opdstack,t);PrintStack1(opdstack);}else//操作数⼊栈{dpush(opdstack,atoi(ctokens[i]));PrintStack1(opdstack);}}value = opdstack->elem[opdstack->top];return value;}。

表达式求值源代码(数据结构课程设计)

表达式求值源代码(数据结构课程设计)
break;
}
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");

表达式求值源代码

表达式求值源代码

#include <cstdio>#include <cstdlib>#include <cmath>#include <stack>#include <cstring>using namespace std;char Precede(char a, char b) { //判断运算符优先级int i, j;char Table[8][8] = {{' ','+','-','*','/','(',')','='},{'+','>','>','<','<','<','>','>'},{'-','>','>','<','<','<','>','>'},{'*','>','>','>','>','<','>','>'},{'/','>','>','>','>','<','>','>'},{'(','<','<','<','<','<','=',' '},{')','>','>','>','>',' ','>','>'},{'=','<','<','<','<','<',' ','='}}; //优先级表格for(i=0; i<8; i++)if(Table[0][i]==a) //寻找运算符abreak;for(j=0; j<8; j++) //寻找运算符bif(Table[j][0]==b)break;return Table[j][i];}bool Calcu_temp(double a, char theta, double b, double &r) { //计算二元表达式的值if(theta=='+')r = a + b;else if(theta=='-')r = a - b;else if(theta=='*')r = a * b;else {if(fabs(b-0.0)<1e-8) //如果被除数为0，返回错误信息return false;elser = a / b;}return true;}bool IsOper(char ch) { //判断字符ch是否为运算符char ptr[10] = {'+', '-', '*', '/', '(', ')', '='};int i;for(i=0; i<7; i++) {if(ch==ptr[i])return true;}return false;}bool Calculate(char s[], double &result) { //计算表达式的结果char theta;int i = 0, j, point = 0;double a, b, r, num = 0;stack<double> num_stack; //数字栈stack<char> oper_stack; //运算符栈oper_stack.push('='); //将等号入栈到运算符栈while(s[i]!='=' || oper_stack.top()!='=') { //对表达式a进行计算if((s[i]>='0' && s[i]<='9') || s[i]=='.') { //字符是数字或者小数点num = 0; //初始化数字为0point = 0; //point用来标记是否出现小数点以及当前处于小数点后第x位，point==10^xif(s[i]=='.')point = 10;elsenum = s[i] - 48;j = i + 1;while(!IsOper(s[j])) { //继续往后查找并记录该数字，直到该数字结束遇到运算符为止if(s[j]=='.') {point = 10;j++;continue;}if(!point) //整数部分num = num * 10 + ( s[j] - 48 );else {num = num + 1.0 * ( s[j] - 48 ) / point; //小数部分point *= 10; //小数位数后移一位}j++;}i = j;num_stack.push(num); //将该数字压入栈中}else if(IsOper(s[i])) { //字符是运算符switch(Precede(s[i],oper_stack.top())) { //该运算符和栈顶运算符进行优先级比较并做相关处理case '<':oper_stack.push(s[i++]);break;case '=':oper_stack.pop();i++;break;case '>':theta = oper_stack.top(); //从栈中弹出一个运算符进行计算oper_stack.pop();b = num_stack.top(); //弹出两个数字，注意顺序，先弹出的数是第二个操作数num_stack.pop();a = num_stack.top();num_stack.pop();if ( Calcu_temp(a, theta, b, r) ) //计算并判断是否有除数等于0的情况num_stack.push(r); //若正常，则将结果压入栈中elsereturn false; //出现除数为0的情况，返回错误信息break;}}}result = num_stack.top(); //最后数字栈中的数即为表达式的最终结果return true;}bool Check(char s[]) { //检查表达式括号是否匹配int flag=0, i;for(i=0; s[i]!=0; i++) {if(s[i]=='(')flag++;if(s[i]==')')flag--;}if(flag)return false;elsereturn true;}int main() {int i, j;char s1[210], s2[210];double result;printf(" 数据结构实训--表达式求值:\n");printf("编程人员：桂林电子科技大学信息科技学院:\n");printf(" 1151220114 章贵萍\n");printf("请输入表达式:\n");while(gets(s1)!=NULL) { //输入表达式if(strlen(s1)==1 && s1[0]=='0')break;for(i=0,j=0; s1[i]!=0; i++) { //将表达式转换为规格化的表达式，并在末尾加上“=”，保存在s2中if(s1[i]==' ')continue;s2[j++] = s1[i];}s2[j++] = '=';s2[j] = '\0';if(Check(s2)) { //检查括号是否匹配if(Calculate(s2, result)) //计算并检查表达式中是否出现除数为0的情况printf("%lf\n",result);elseprintf("被除数为零，该表达式无效!\n");}elseprintf("该表达式括号不匹配!\n");}return 0;}[文档可能无法思考全面，请浏览后下载，另外祝您生活愉快，工作顺利，万事如意!]。

java计算算术表达式

java计算算术表达式

java计算算术表达式Java计算算术表达式是一个常见的编程任务，可以通过使用Java 的Scanner类和Math类来实现。

以下是一个简单的Java程序，可以计算一个算术表达式的值：```javaimport java.util.Scanner;public class ArithmeticExpressionCalculator {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入算术表达式：");String expression = scanner.nextLine();scanner.close();double result = calculateExpression(expression);System.out.println("计算结果为：" + result);}public static double calculateExpression(String expression) {String[] tokens = expression.split(" ");double a = Double.parseDouble(tokens[0]);double b = Double.parseDouble(tokens[2]);double c = Double.parseDouble(tokens[4]);double d = Double.parseDouble(tokens[6]);double e = Double.parseDouble(tokens[8]);char op1 = tokens[1].charAt(0);char op2 = tokens[3].charAt(0);char op3 = tokens[5].charAt(0);char op4 = tokens[7].charAt(0);double result;switch (op1) {case '+': result = a + b; break;case '-': result = a - b; break;case '*': result = a * b; break;case '/': result = a / b; break;default: throw new IllegalArgumentException("Invalid operator: " + op1);}switch (op2) {case '+': result += c; break;case '-': result -= c; break;case '*': result *= c; break;case '/': result /= c; break;default: throw newIllegalArgumentException("Invalid operator: " + op2);}switch (op3) {case '+': result += d; break;case '-': result -= d; break;case '*': result *= d; break;case '/': result /= d; break;default: throw new IllegalArgumentException("Invalid operator: " + op3);}switch (op4) {case '+': result += e; break;case '-': result -= e; break;case '*': result *= e; break;case '/': result /= e; break;default: throw new IllegalArgumentException("Invalid operator: " + op4);}return result;}}```。

表达式求值c语言程序

表达式求值c语言程序

#include <stdio.h>#include <stdlib.h>typedef struct opLnode{char op;opLnode *next;}opLnode,*opLinkList;void OpInitStack(opLinkList &L) //运算符生成栈{L=(opLinkList)malloc(sizeof(opLnode));L->next=NULL;}void OpPush(opLinkList &L,char x) //运算符入栈{opLinkList p;p=(opLinkList)malloc(sizeof(opLnode));p->op=x;p->next=L->next;L->next=p;}char OpPop(opLinkList &L,char x) //栈顶运算符元素出栈{opLinkList p;p=(opLinkList)malloc(sizeof(opLnode));p=L->next;x=p->op;L->next=p->next;free(p);return x;}char OpGetTop(opLinkList L,char x) //读栈顶运算符元素{L=L->next;x=L->op;return x;}typedef struct Lnode{int i;Lnode *next;}Lnode,*LinkList;void InitStack(LinkList &L) //数值生成栈{L=(LinkList)malloc(sizeof(Lnode));L->next=NULL;}void Push(LinkList &L,int x) //数值入栈{LinkList p;p=(LinkList)malloc(sizeof(Lnode));p->i=x;p->next=L->next;L->next=p;}int Pop(LinkList &L,int x) //栈顶数值元素出栈{LinkList p;p=(LinkList)malloc(sizeof(Lnode));p=L->next;x=p->i;L->next=p->next;free(p);return x;}int GetTop(LinkList L,int x) //读栈顶数值元素{L=L->next;x=L->i;return x;}int GetNumber(char ch) //字符转化为数字{return (ch-48);int JudgeOp(char a) //判断输入是否为运算符{switch (a){case'+':case'-':case'*':case'/':case'(':case')':case'=':return 1;break;default:return 0;break;}}int JudgeNum(char a) //判断输入是否为为数字{switch(a){case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':return 1;break;default:return 0;break;}}char Precede(char a,char b) //比较两运算符的“大小”switch (a){case'+':case'-':{if('*'==b||'/'==b||'('==b){return '<';}else{return '>';}break;}case'*':case'/':{if('('==b){return '<';}else{return '>';}break;}case'(':{if(')'==b){return '=';}else{return '<';}break;}case')':{return '>';break;}case'=':{if('='==b){return '=';}else{return '<';}break;}default:break;}}int Operate(int a,char op,int b) //运算{int c;switch (op){case '+':{c=a+b;break;}case '-':{c=a-b;break;}case '*':{c=a*b;break;}case '/':{c=a/b;break;}default:break;}return c;}int main(){printf("本程序只能计算整型数据，小数部分自动舍弃。

数据结构课程设计之算术表达式求值

数据结构课程设计之算术表达式求值

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【实现效果】完全可以实现题目的要求，除了下图的错误提示，本程序还可以提示的错误有：输入过多运算符，缺少反括号，两个括号之间缺少运算符相连，缺少左括号，输入的运算符超出范围等提示。

数据结构之算术表达式求值C语言编写

数据结构之算术表达式求值C语言编写

#include <stdio.h>#include <string.h>#include <stdlib.h>#define MAXLEN 100typedef struct{char ch;int level;}opt;typedef struct //定义操作栈{opt st[MAXLEN];int top;}Tstack;typedef struct //定义数据栈{double D[MAXLEN];int top;}Nstack;void Unit(Tstack *s) //初始化操作栈{s->top=-1;}//Unitvoid DUnit(Nstack *s) //初始化数据栈{s->top=-1;}//DUnitchar Push(Tstack *s,opt c) //入操作栈{s->top++;s->st[s->top]=c;return c.ch;}//Pushdouble DPush(Nstack *s,double c) //入数据栈{s->top++;s->D[s->top]=c;return c;}//DPushopt Top(Tstack *s) //操作栈栈顶{opt error={'$',-2};if(s->top>=0)return s->st[s->top];elsereturn error;}//Topdouble DTop(Nstack *s) //数据栈栈顶{if(s->top>=0)return s->D[s->top];elsereturn 0;}//DTopopt Pop(Tstack *s) //出操作栈{opt i;opt error={'$',-2};if(s->top>=0){i=s->st[s->top];s->st[s->top].ch='\0';s->top--;return i;}elsereturn error;}//Popdouble DPop(Nstack *s) //出数据栈{double i;if(s->top>=0){i=s->D[s->top];s->D[s->top]='\0';s->top--;return i;}else return 0;}//DPopint Empty(Tstack *s) //判断操作栈空{if(s->top<0)return 0;elsereturn s->st[s->top].ch;}//Emptyint NEmpty(Nstack *s) //判断数据栈空{if(s->top<0)return 0;elsereturn (int)(s->D[s->top]);}//NEmptydouble valuate(char *e) //计算{Tstack T;Nstack N;char tmp[MAXLEN]={'\0'};int i=0,leng;double d,dp;opt A={'+',1};opt R={'-',1};opt M={'*',2};opt D={'/',2};opt B={'(',-1};Unit(&T);DUnit(&N);while(*e!='\0'){while(*e >= '0' && *e <= '9' || *e == '.'){while(*e >= '0' && *e <= '9' || *e == '.'){tmp[i++]=*e++;}d=atof(tmp);DPush(&N,d);leng=strlen(tmp);for(i=0;i<leng;i++){tmp[i]='\0';}i=0;}switch(*e){case '+' :if(!Empty(&T) || Top(&T).level < A.level) {Push(&T,A);*e++;}else{while(Empty(&T) && Top(&T).level>=A.level) {switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);DPush(&N,dp);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;DPush(&N,dp);break;case '+':dp=DPop(&N)+DPop(&N);DPush(&N,dp);break;case '-':dp=DPop(&N);dp=DPop(&N)-dp;DPush(&N,dp);break;}}Push(&T,A);*e++;}break;case '-':if(!Empty(&T) || Top(&T).level < R.level) {Push(&T,R);*e++;}else{while(Empty(&T) && Top(&T).level>=R.level) {switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;DPush(&N,dp);break;case '+':dp=DPop(&N)+DPop(&N);DPush(&N,dp);break;case '-':dp=DPop(&N);dp=DPop(&N)-dp;DPush(&N,dp);break;}}Push(&T,R);*e++;}break;case '*':if(!Empty(&T) || Top(&T).level < M.level) {Push(&T,M);*e++;}else{while(Empty(&T) && Top(&T).level>=M.level) {switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);DPush(&N,dp);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;break;}}Push(&T,M);*e++;}break;case '/':if(!Empty(&T) ||Top(&T).level < D.level){Push(&T,D);*e++;}else{while(Empty(&T) &&Top(&T).level>=D.level) {switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);DPush(&N,dp);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;DPush(&N,dp);break;}}Push(&T,D);*e++;}break;case '(':Push(&T,B);e++;break;case ')':while(Top(&T).level!=-2){switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);DPush(&N,dp);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;DPush(&N,dp);break;case '+':dp=DPop(&N)+DPop(&N);DPush(&N,dp);break;case '-':dp=DPop(&N);dp=DPop(&N)-dp;DPush(&N,dp);break;}}Pop(&T);e++;break;}}while(Empty(&T)){switch(Pop(&T).ch){case '*' :dp=DPop(&N)*DPop(&N);DPush(&N,dp);break;case '/' :dp=DPop(&N);dp=DPop(&N)/dp;DPush(&N,dp);break;case '+':dp=DPop(&N)+DPop(&N);DPush(&N,dp);break;case '-':dp=DPop(&N);dp=DPop(&N)-dp;DPush(&N,dp);break;}}return DPop(&N);}//valuatevoid main(){char string[MAXLEN];char *p=string;printf("输入表达式:\n");gets(p);printf("%s=%f\n\n",string,valuate(p)); }。

算术表达式求值

算术表达式求值

////////算术表式求值.h#include <stdio.h>#include <malloc.h>#define MAXSIZE 50typedef struct{char data[MAXSIZE];int top;}SeqStackc,*PseqStackc;//定义一个线性表栈。

PseqStackc Init_SeqStackc(void){PseqStackc S;S=(PseqStackc)malloc(sizeof(SeqStackc));if(S)S->top=-1;return(S);}//初始化栈。

int Empty_SeqStackc(PseqStackc S){if(S->top==-1)return(1);else return (0);}//判断是否栈空。

int Push_SeqStackc(PseqStackc S,char x){if(S->top==MAXSIZE-1)return (0);else{S->top++;S->data[S->top]=x;return (1);}}//入栈。

int Pop_SeqStackc(PseqStackc S,char *x){if(Empty_SeqStackc(S))return (0);else{*x=S->data[S->top];S->top--;return (1);}}//出栈。

int GetTop_SeqStackc(PseqStackc S,char *x) {if(Empty_SeqStackc(S))return (0);else*x=S->data[S->top];return (1);}//取栈顶元素。

void Destroy_SeqStackc(PseqStackc *S){if (*S)free(*S);*S=NULL;return ;}//销毁栈。

实验四 算术表达式求值源代码

实验四 算术表达式求值源代码

} } OPND[topNd]=number; //操作数进栈 topNd++; break; case POINT: //小数点，以小数点开头的实数 number=0; temp=10.0; pp++; while(str[pp]>='0' && str[pp]<='9') { number=number+(str[pp]-48)/temp; temp=temp*10; pp++; } OPND[topNd]=number; topNd++; break; case PLUS: //+ case MINUS: //case POWER: //* case DIVIDE: /// ########################## { int i,j; i=PriorityTable[OPTR[topTr-1]][CharType];//栈顶元素比较小，直接输入 if(i==-1) {OPTR[topTr]=CharType; topTr++; } if(i==1)//栈顶元素比较大 {while(i==1)//弹出操作数元素开始计算 { j=OPTR[topTr-1]; if(j==0)//+ OPND[topNd-2]=OPND[topNd-2]+OPND[topNd-1]; if(j==1)//OPND[topNd-2]=OPND[topNd-2]-OPND[topNd-1]; if(j==2)//* OPND[topNd-2]=OPND[topNd-2]*OPND[topNd-1]; if(j==3)/// OPND[topNd-2]=OPND[topNd-2]/OPND[topNd-1]; topNd--; topTr--; i=PriorityTable[OPTR[topTr-1]][CharType];//此时判断是否循环 }
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

#include<stdio.h>#include<conio.h>#include<stdlib.h>#define FALSE 0#define TRUE 1#define MAXSIZE 100 /*存储空间初始分配量*/#define N 10 /*存储空间增加量*/#define NULL 0typedef struct StStack{float *base; /*在栈构造之前和销毁之后，base的值为0*/float *top; /*栈顶指针*/int size; /*当前已分配的存储空间，以元素为单位*/}StStack;typedef struct StStack_c{char *base;char *top;int size;}StStack_c;void InitStack(StStack *S){/*构造一个空栈S存储数据*/S->base=(float *)malloc(MAXSIZE*sizeof(float));if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base;S->size=MAXSIZE;}void InitStack_c(StStack_c *S){/*构造一个空栈S存储符号；*/S->base=(char *)malloc(MAXSIZE*sizeof(char));if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base;S->size=MAXSIZE;}void Push(StStack *S,float e){/*插入元素e为新的栈顶元素*/if(S->top==S->base+S->size){ S->base=(float *)realloc(S->base,(S->size+N)*sizeof(float)); /*若栈满则增存储空间*/if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base+S->size; /*增加存储空间*/S->size+=N;}S->base[(S->top++)-S->base]=e;}void Push_c(StStack_c *S,char ch){/*插入元素ch为新的栈顶元素*/if(S->top==S->base+S->size){ S->base=(char *)realloc(S->base,(S->size+N)*sizeof(char)); /*若栈满则增存储空间*/if(!S->base) exit(TRUE); /*存储分配失败*/S->top=S->base+S->size;S->size+=N;}S->base[(S->top++)-S->base]=ch;}void Pop(StStack *S,float *e){/*若栈不空，则删除S的栈顶元素，用e返回其值*/if(S->top!=S->base)*e=S->base[(S->top--)-S->base-1];}void Pop_c(StStack_c *S,char *ch){/*若栈不空，则删除S的栈顶元素，用ch返回其值*/if(S->top!=S->base)*ch=S->base[(S->top--)-S->base-1];}float GetTop(StStack *S){/*若栈不空，则用e返回S的栈顶元素*/int n; /*存放栈顶元素的位置*/float e;if(S->top!=S->base){n=S->top-S->base-1;e=S->base[n];return e; /*返回S的栈顶元素*/}}char GetTop_c(StStack_c *S){/*若栈不空，则用ch返回S的栈顶元素*/int n;char ch;if(S->top!=S->base){n=S->top-S->base-1;ch=S->base[n];return ch;}}int In_c(char ch){/*判断是否为运算符，是则返回TRUE，否则返回FALSE*/if(ch=='+'||ch=='-') return TRUE;else if(ch=='*'||ch=='/') return TRUE;else if(ch=='('||ch==')') return TRUE;else if(ch=='#') return TRUE;else return FALSE;}int check_ch(char *ch){/*判断输入是否符合表达式的要求*/while(*ch!='#'){if(*ch=='.'||*ch>='0'&&*ch<='9'||In_c(*ch)) /*表达式的限制条件*/{if(*ch>='0'&&*ch<='9') {ch++;continue;}if(*ch=='.') /*小数点前后不是数字的处理*/{if(In_c(*(++ch))) return FALSE;else ch--;if(In_c(*(--ch))) return FALSE;else ch++;}/*if-2*/else{if(In_c(*(++ch))&&In_c(*(--ch))) /*相邻的两运算符的处理*/{if(*(++ch)=='(') continue; /*在'('前的运算符情况处理*/else ch--;if(*(++ch)=='-'&&*(--ch)=='(') {ch++; continue;} /*()内第一位数为负的运算符处理*/else ch--;if(*(++ch)!='#'&&*(--ch)==')') {ch++; continue;} /*在')'后的运算符情况处理*/else if(*ch--!='#') return FALSE;}/*if-3*/else ch--;}/*if-else2*/ch++;}/*if-1*/else return FALSE;}/*while*/if(*ch=='#') return TRUE;}float operate(float x,char c,float y){/*基本运算的实现*/switch(c){case '+': return x+y;case '-': return x-y;case '*': return x*y;case '/': if(y!=0) return x/y; /*被除数不为0*/ else{printf("\nThe divisor is 0,can't permit !\n");exit(1);}}}char Precede(char x,char y){/*运算符的优先权*/switch(x){case '+': if(y=='*'||y=='/'||y=='(') return '<';else return '>';case '-': if(y=='*'||y=='/'||y=='(') return '<';else return '>';case '*': if(y=='(') return '<';else return '>';case '/': if(y=='(') return '<';else return '>';case '(': if(y==')') return '=';else return '<';case ')': if(y!='(') return '>';case '#': if(y=='#') return '=';else if(y!=')') return '<';}}int changeN(StStack *S,char *ch){/*将字符转换为数值*/int j,h,k=0;float m,n=0;char c;while(*ch>='0'&&*ch<='9'||*ch=='.'){n=n*10+(*ch-48); /*将字符转换为数值存入n中*/k++; /*k记录数值的位数*/ch++;if(*ch=='.') /*若有小数，将n,k存入m,h，并初始化方便小数的转换*/ {m=n;n=0;h=k;k=0;c=*ch;ch++; /*将'.'存入c,对下一个字符进行操作*/}if(c=='.'&&In_c(*ch)==TRUE) /*对小数部分的处理*/{for(j=0;j<k;j++)n=n/10;n+=m;k=++k+h;}}/*while*/Push(S,n); /*将转换好的数值入栈*/return k; /*返回数值的位数*/}int DealNeg(StStack *S,char *ch){/*对括号内负数的处理*/int k=0,i=0;float e,n=0;if(*(--ch)=='('&&*(++ch)=='-'){k=changeN(S,++ch);Pop(S,&e);n=-1*e;Push(S,n);return k;}else return FALSE;}void Operating(char *c,StStack *OPND,StStack_c *OPTR)/*表达式运算过程*/{char ch;int k=0,i=0;float a,b,e;if(c[0]=='-'&&(!In_c(c[1]))) /*判断首数是负数则进栈*/{k=changeN(OPND,&c[1]);i+=k+1; /*首数是负数保存其位数*/Pop(OPND,&e);e=-1*e; /*保存负数*/Push(OPND,e);}do{if(!In_c(c[i])) /*不是运算符则转换为数值并进栈*/{k=changeN(OPND,&c[i]);i+=k-1; /*下一个字符在串中的下标*/}else{if(k=DealNeg(OPND,&c[i])) i+=k; /*判断是负数则进栈*/else{switch(Precede(GetTop_c(OPTR),c[i])){case '<': Push_c(OPTR,c[i]); /*栈顶元素优先权低*/ break;case '=': Pop_c(OPTR,&ch); /*脱括号并接收下一字符*/ break;case '>': Pop_c(OPTR,&ch); /*退栈并将输出结果入栈*/ Pop(OPND,&b);Pop(OPND,&a);e=operate(a,ch,b); /*将运算结果存入e中*/if(GetTop_c(OPTR)=='-') /*若结果前为'-'则取其相反数*/{Pop_c(OPTR,&ch);Push_c(OPTR,'+');e=-1*e;}Push(OPND,e);if(c[i]!='#'&&c[i]!=')') /*当前符号不是'#'则入栈*/ Push_c(OPTR,c[i]);else i--;}/*switch()*/}/*if-else-1*/}/*if-else-2*/i++;}while(GetTop_c(OPTR)!='#'||c[i]!='#'); /*判断表达式是否结束*/}void main(){char str[40 ],*c,ch;float i=0,n,f;FILE *fp;StStack s1,*OPND; /*定义关于数值的栈*/StStack_c s2,*OPTR; /*定义关于字符的栈*/OPND=&s1;OPTR=&s2;clrscr();c=str;if((fp=fopen("date.txt","w"))==NULL) /*打开文档并将正确的表达式和结果写入文档*/{printf("can't open the file.\n");i=1;} /*出错提示*/do{InitStack_c(OPTR);Push_c(OPTR,'#');InitStack(OPND);do{printf("\nPlease input the expression: ");scanf("%s",c);getchar();if(check_ch(c)) f=1;else{printf("\nWarning: the expression you input is non-standard!!\n");f=0;}}while(f!=1); /*表达式若不符合要求则重新输入*/Operating(c,OPND,OPTR);n=GetTop(OPND);printf("\nThe result of the expression is: %.2f.\n",n);if(i!=1) /*将表达式和结果写入文档*/{fputs("\nThe expression is: \0",fp);fputs(c,fp);fputs("\nThe result is: \0",fp);fprintf(fp,"%.2f",n);}printf("\nDo you want to calculate the next expression(y/n): ");ch=getchar(); getchar();}while(ch=='y'||ch=='Y');fclose(fp); /*关闭文件*/}。

相关文档
最新文档