用两种方式实现表达式自动计算
一、设计思想
计算表达式有两种方法:
第一种方法：直接计算表达式：
具体实现思想如下：
通过get()函数，输入所要计算的表达式。调用calculate(char ch[])函数，然后
先建立两个栈，一个数值栈，一个操作符栈，同时将两个栈初始化为空，利用while
循环获取表达式字符，并对表达式字符进行判断，如果是空格则直接跳过，如果是
0到9的数字或者小数点‘.’,则利用trans()函数把数字转化为浮点型的数，然后
在将浮点型的数值压栈，如果是操作符，则先判断操作符栈是否为空，如果为空，
则操作符直接入栈，如果不为空，则先判断是不是右括号，如果是，则将栈顶元素
出栈，并将数值栈中的两个元素出栈，进行相应的运算，然后把结果入栈，直到遇
到左括号为止，并且把左括号出栈，如果不为左括号，则比较所扫描元素与栈顶元
素的优先级，如果所扫描元素的优先级高于栈顶元素的优先级，则把所扫描元素直
接入栈，如果所扫描元素的优先级低于栈顶元素的优先级，则先判断栈顶是不是左
括号，如果是左括号则直接入栈，如果不是左括号，则将栈顶元素出栈，并将数值
栈中的两元素出栈，进行相应的运算，然后把结果放入数值栈中，知道所扫描元素
的优先级高于栈顶元素的优先级为止，如果扫到了表达式的结尾，即扫到了‘\0’，
则判断此时操作符栈是否为空，如果不为空，则把操作符栈中的操作符出栈，并将
数值栈中的两个数值出栈进行相应的运算，然后压入数值栈，知道操作符栈为空为
止。最后将最后结果从数值栈中出栈，并返回此结果。此时表达式就计算出了最后
结果。
第二种方法:先把中缀表达式转化为后缀表达式,然后在对后缀表达式进行计算。
具体实现思想如下：
1、中缀表达式转为后缀表达式：在主函数中通过gets()函数获得要进行计算的表达式，
然后调用中缀转换函数transform(char exp[],char tem[])，然后先定义一个操作
符栈，并初始化为空，利用while循环获得表达式字符，并进行判断，如果是空格
则直接跳过，如果不是空格，则判断是不是0到9的数字或者小数点‘.’，如果
是则把此数字字符赋给字符数组tem[]，如果是操作符，则先判断操作符栈是不是
为空，如果为空，则操作符直接压入栈中，如果不是为空，则判断是不是右括
号，如果是右括号，则将栈顶元素出栈，赋给字符数组，tem[]，知道遇到左括号
为止，如果不是左括号，则比较所扫描元素与栈顶元素的优先级，如果所扫描元
素的优先级高于栈顶元素的优先级，则直接入栈，如果所扫描元素的优先级小于
栈顶元素的优先级，则判断栈顶元素是不是左括号，如果是左括号，则所扫描元
素直接入栈，如果不是左括号则将栈顶元素出栈并赋给字符数组tem[]，知道遇到
所扫描元素的优先级高于栈顶元素的情况为止。如果扫到字符串结束标志，即
‘\0’，则利用while循环将操作符栈中的操作符全部出栈，并赋给字符数组
tem[]，然后将tem[]数组返回。
2、后缀表达式计算：调用后缀表达式计算函数calculate(char ch[])，建立一个数
值栈，并初始化为空，然后利用while循环获得表达式字符，并进行判断，如果是
数字字符，则将数字字符利用trans()函数转化为浮点型的数字，并将转化后的数
字压入数值栈，如果是操作符，则从数值栈将两个数值出栈并进行相应的运算，
然后将计算结果压入数值栈，当扫到后缀表达式结尾的时候，将数值栈中的最后
结果出栈并返回，此时表达式就计算出了最后结果。
二、算法流程图
第一种算法：直接计算表达式，其流程图为：
图1 直接计算算法流程图
第二种算法：先中缀表达式转化为后缀表达式，然后在计算后缀表达式，其流程图为：
图2 中缀转后缀算法流程图
图3 后缀表达式计算算法流程图
三、源代码
下面给出的是用直接计算算法实现的程序的源代码：/* Note:Your choice is C IDE */
/*表达式直接运算*/
#include"stdio.h"
#include"stdlib.h"
#define Maxsize 100
/////////////////////////////////////////////////////
////定义操作符栈
typedef struct{/////定义操作符栈
char data[Maxsize];
int top;
}Stack;
void InitStack(Stack *S) /////用于初始化栈
{
S->top=-1;
}
int push(Stack *S,char op)//将一个新元素压入栈中
{
if(S->top==Maxsize-1) ///判断栈是否为空，并进行处理{
printf("\n stack is full");
return 0; /////如果栈满则返回0值}
S->top++;
S->data[S->top]=op; ////把元素压入栈顶
return 1;
}
char pop(Stack *S) /////定义出栈函数
{
if(S->top==-1) /////判断栈是否为空
{
printf("the stack is empty");
return 0;
}
return S->data[S->top--]; /////返回栈顶元素
}
////////////定义数值栈
typedef struct{////定义数值栈
double data1[Maxsize];
int top;
}ODStack;
void InitStack1(ODStack *S) //////初始化栈
{
S->top=-1;
}
int push1(ODStack *S,double OpNd)//将一个新元素压入栈中{
if(S->top==Maxsize-1) ///判断栈是否为空，并进行处理{
printf("\n stack is full");
return 0;
}
S->top++;
S->data1[S->top]=OpNd; /////把元素压入栈顶
return 1;
}
double pop1(ODStack *S) ///////出栈函数
{
if(S->top==-1) //////判断栈是否为空
{
printf("the stack is empty");
return 0;
}
return S->data1[S->top--]; /////返回栈顶元素
}
/////////定义优先级
int level(char oper)
{int lvl; /////定义记录优先级的变量switch(oper)
{
case'+': lvl=1;break;
case'-':lvl=1;break; ////定义…-?…+?的优先级
case'*':lvl=2;break;
case'/':lvl=2;break; ////定义…*?…、?的优先级
case'%':lvl=2;break; ////定义…%?的优先级
case'(':lvl=6;break;
case')':lvl=0;break; ////定义…（?…）?的优先级}
return lvl; //////返回操作符的优先级
}
int precede(char oper1,char oper2)////进行优先级比较
{
int result;
result=level(oper1)-level(oper2);
return result; ////返回优先级比较结果
}
void main()
{
double calculate(char ch[]);
char expression[Maxsize]; /////声明要使用的函数
printf("Attention!!!:the side of '%' must be intgral number\n");
printf("please input the expression :");
gets(expression); ////输入所要计算的算式
printf("the value after calculating the expression is: %.4f\n",calculate(expression));
//////输出计算结果
}
////////////////////////////////////////////////////
////////////定义计算表达式
double calculate(char ch[])
{double cal(double tem1,double tem2,char c);
//////////声明cal()函数
int i=0,k=0;
char transform[Maxsize],*s_t;////声明存放数值的字符数组
char tem;
double d1,d2,od1,od2,result;
Stack Optr; //////声明数值栈
ODStack Opnd; //////声明操作符栈
InitStack(&Optr); ///////初始化操作符栈
InitStack1(&Opnd); /////初始化数值栈
while(ch[i]!='\0') /////扫描后缀表达式
{
if(ch[i]==' ') ////跳过空格
{
i++;
}
if(ch[i]>='0'&&ch[i]<='9'||ch[i]=='.')///判断是不是数值
{
while(ch[i]>='0'&&ch[i]<='9'||ch[i]=='.')//将字符转化为浮点型
{
transform[k]=ch[i]; /////将数值字串的每一个字符赋给trans数组
k++;
i++;
}
transform[k]='\0'; ///以…\0?结尾存放数值串
k=0;
s_t=transform;
d1=atof(s_t); ////利用atof()函数将转为浮点型
push1(&Opnd,d1);
// printf("the top of the stack is:%f\n",Opnd.data1[Opnd.top]);
}
else/////对操作符进行操作
{
if(Optr.top==-1) ///判断站的状态，空则直接压入
{
push(&Optr,ch[i]); /////入栈
}
else
{
if(ch[i]==')') ///判断是不是'）',对括号内的表达式进行运算
{
while( Optr.data[Optr.top]!='(')////以…）?为条件处理括号内的操作符
{
tem=pop(&Optr); /////栈顶元素出栈
od2=pop1(&Opnd); ////将符号右元素出栈
od1=pop1(&Opnd); ////将符号左元素出栈
d2=cal(od1,od2,tem); /////调用计算函数
push1(&Opnd,d2); ////将所得结果压入数值栈
}
pop(&Optr); ////(出栈
}
else///////对操作符进行处理
{
if(precede(ch[i],Optr.data[Optr.top])<=0&&Optr.top>=0) //栈顶元素大于所扫描元素的情况
{
while(precede(ch[i],Optr.data[Optr.top])<=0&&Optr.top!=-1)
{
if(Optr.data[Optr.top]=='(')/////如果是…（?直接进行操作符运算
break;
tem=pop(&Optr); ///栈顶元素出栈
od2=pop1(&Opnd); ////将符号右元素出栈
od1=pop1(&Opnd); ////将符号左元素出栈
d2=cal(od1,od2,tem);////调用计算函数
push1(&Opnd,d2); ///将所得结果压入栈中
}
push(&Optr,ch[i]); ////当栈顶元素优先级小于所扫描元素时，将元素入栈
}
if(precede(ch[i],Optr.data[ Optr.top])>0)///优先级大于栈顶元素的时候直接入栈
{
push(&Optr,ch[i]); /////入栈
}
}
}
i++; /////使i加1保证循环继续进行
}
}
//printf("ddddddd%c\n",Optr.data[Optr.top]);
while(Optr.top!=-1) ///将操作符栈中的操作符全部出栈并运算
{
tem=pop(&Optr); ///操作符出栈
od2=pop1(&Opnd); // 操作符右元素出栈
od1=pop1(&Opnd); //操作付左操作付出栈
d2=cal(od1,od2,tem);///调用计算函数
push1(&Opnd,d2); ////将所得结果入栈
}
result=pop1(&Opnd); ///将所得最后结果出栈
return(result); ///返回算式结果
}
///////////////////////////////////////////
////定义基本计算函数
double cal(double tem1,double tem2,char c)
{
double tem; //声明变量tem用以存放计算结果
switch(c)
{
case'+':tem=tem1+tem2; break;//加法
case'-':tem=tem1-tem2; break;///减法
case'/':tem=tem1/tem2; break;//除法
case'*':tem=tem1*tem2; break;//乘法
case'%':tem=(double)((int)tem1%(int)tem2);
}
return tem; ////返回计算结果
}‘
下面给出的是用中缀转后缀然后在计算算法实现的程序的源代码：/* Note:Your choice is C IDE */
/////后缀表达式计算
#include"stdio.h"
#include"stdlib.h"
#define Maxsize 100
#define addsize 20
/////////////////////////////////////////////////////
////定义操作符栈
typedef struct{//////////建立操作符栈
char data[Maxsize];
int top;
}Stack;
void InitStack(Stack *S) ///////////初始化栈
{
S->top=-1;
}
int push(Stack *S,char op) //将一个新元素压入栈中
{
if(S->top==Maxsize-1) ///判断栈是否为空，并进行处理{
printf("\n stack is full");
return 0;
}
S->top++;
S->data[S->top]=op; //////将元素op压入栈
return 1;
}
char pop(Stack *S) ///////////将栈顶元素出栈
{
if(S->top==-1) ////////////////////判断栈是否为空{
printf("the stack is empty");
return 0;
}
return S->data[S->top--]; /////不为空进行出栈操作
}
////////////定义数值栈
typedef struct{
double data1[Maxsize];
int top;
}ODStack;
void InitStack1(ODStack *S)
{
S->top=-1;
}
int push1(ODStack *S,double OpNd) //将一个新元素压入栈中
{
if(S->top==Maxsize-1) ///判断栈是否为空，并进行处理{
printf("\n stack is full");
return 0;
}
S->top++;
S->data1[S->top]=OpNd; //////////进行压栈操作
return 1;
}
double pop1(ODStack *S) ////将栈顶元素出栈
{
if(S->top==-1) ///////判断栈是否为空
{
printf("the stack is empty");
return 0;
}
return S->data1[S->top--]; ////////返回栈顶元素的值
}
/////////定义优先级
int level(char oper)
{int lvl;
switch(oper) ///////由switch选择函数来定义优先级
{
case'+': lvl=1;break;
case'-':lvl=1;break; //////定义“+”“-”的优先级
case'*':lvl=2;break;
case'/':lvl=2;break; //////定义“/”“*”的优先级
case'%':lvl=2;break; //////定义“%”的优先级
case'(':lvl=6;break;
case')':lvl=0;break; ///////定义括号的优先级
}
return lvl; /////返回操作符的优先级
}
int precede(char oper1,char oper2) /////优先级比较函数
{
int result;
result=level(oper1)-level(oper2);
return result; ////////////返回优先级比较结果
}
void main()
{
double calculate(char ch[]);
void transform(char exp[],char tem[]); ///////进行函数声明
char expression[Maxsize],temp[Maxsize];///////定义存放表达式的数组
printf("Attention!!!:the side of '%' must be integral number\n");
printf("please input the expression :");
gets(expression); //////表达式输入函数
transform(expression,temp); //////前缀转后缀函数调用
printf("the expression after changing is:%s\n",temp);////输出后缀表达式
printf("the value after calculating the expression is: %.4f\n",calculate(temp));///输出计算结果}
////////////////////////////////////////////////////////////////////
/////////定义前缀转后缀的函数
void transform(char exp[],char tem[])
{
int i=0,k=0;
Stack optr; //////定义操作符栈
InitStack(&optr); ///////初始化操作符栈
while(exp[i]!='\0') ////////对表达式进行扫描，以符号“\0”
{
if(exp[i]==' ') ///////判断字符是否为空格
{i++;
continue;
}
if(exp[i]>='0'&&exp[i]<='9'||exp[i]=='.')//////判断字符是否为0到9的数字或小数点
{
tem[k]=exp[i];
k++;
}
else///////////////////对字符进行操作
{
tem[k++]='#'; //////////////用做数字间的分隔符
if(optr.top==-1)
{
push(&optr,exp[i]);
}
else
{
if(exp[i]==')') //////////判断是否为“）”，并进行相应的操作
{
while(optr.data[optr.top]!='(')/////利用while循环来pop出栈顶元素，直到遇到“）”
{
tem[k]=pop(&optr);
k++;
}
pop(&optr); /////////使“（“出栈
}
else
{
if(precede(exp[i],optr.data[ optr.top])<=0)//对所扫描元素优先级小于栈顶元素的情况进行处理
{
while(precede(exp[i],optr.data[optr.top])<=0&&optr.top!=-1)
{
if(optr.data[optr.top]=='(') ////判断栈顶元素是否为“（”
break;
tem[k]=pop(&optr);
k++;
}
push(&optr,exp[i]); /////将所扫描元素压栈
}
if(precede(exp[i],optr.data[ optr.top])>0)////对优先级大于栈顶元素的情况进行处理，
{
push(&optr,exp[i]); /////将元素直接入栈
}
}
}
}
i++; /////保证循环继续进行，继续扫描下一个元素}
while(optr.top!=-1) /////将操作符栈中的元素全部出栈，以top等于-1为界
{
tem[k++]=pop(&optr);
}
tem[k]='\0'; //////使tem以字符串形势存在
}
////////////////////////////////////////////////////////////////////////////////////
/////////后缀表达式计算函数
double calculate(char ch[])
{
int i=0,k=0;
char transform[Maxsize],*st; /////声明存放数字字符的数组trans,以及指向他的指针
double d1,od1,od2,tem_r,result;
ODStack opnd; ////声明数值栈
InitStack1(&opnd); /////初始化数值栈
while(ch[i]!='\0') ///////对后缀表达式进行扫描，以…\0'为界
{if(ch[i]=='#') ///////判断数字之间的分隔符，
{
i++;
}
if(ch[i]>='0'&&ch[i]<='9'||ch[i]=='.')///////判断是否为数值
{
while(ch[i]>='0'&&ch[i]<='9'||ch[i]=='.')////一循环方式得到一个完整的数
{
transform[k]=ch[i]; ////把数字一字符形式存放在数组trans中
k++;
i++;
}
transform[k]='\0'; //////使字符以字符串的形式贮存
k=0;
st=transform;
d1=atof(st); //////利用atof()函数将字符型数组转化为浮点型的push1(&opnd,d1);
}
else
{
switch(ch[i]) ///////以c为入口，选择所要进行的运算
{
case'+':od2=pop1(&opnd); /////进行加法运算，并第二个数出栈
od1=pop1(&opnd); /////第一个数出栈
tem_r=od1+od2; /////进行加法运算
push1(&opnd,tem_r);/////将结果入栈
break;
case'-':od2=pop1(&opnd); //////进行减法运算，并第二个数出栈
od1=pop1(&opnd); ///////第一个数出栈
tem_r=od1-od2; //////进行减法出栈
push1(&opnd,tem_r);/////将结果入栈
break;
case'/':od2=pop1(&opnd); ////////进行除法运算，并第二个数出栈
od1=pop1(&opnd);////////第一个数出栈
tem_r=od1/od2; //////进行除法运算
push1(&opnd,tem_r);/////将结果入栈
break;
case'*':od2=pop1(&opnd);////////进行除法运算，第二个数出栈
od1=pop1(&opnd);///////第一个数出栈
tem_r=od1*od2; //////进行乘法运算
push1(&opnd,tem_r);/////将运算结果入栈
break;
case'%': od2=pop1(&opnd); //进行取余运算，第二个数出栈
od1=pop1(&opnd);///////第一个数出栈
tem_r=(double)((int)od1%(int)od2);////进行取余运算
push1(&opnd,tem_r);////将运算结果入栈
break;
}
i++; //////确保循环继续进行
}
}
result=pop1(&opnd); ////把运算结果出栈
return result; ///////返回运算结果
}
四、运行结果
图 4 直接运算运行结果图
图 5 中缀转后缀，后缀再运算运行结果图
五、遇到的问题及解决
这部分我主要遇到了如下两个问题，其内容与解决方法如下所列：
●在中缀表达式转后缀表达式时，循环条件思考不周全,具体描述如下:
在扫描表达式时，当所扫描字符是操作符时，开始检测栈顶为空这种情况，当栈不
为空时，要比较所扫描元素与栈顶元素的优先级，当栈顶优先级低的时候直接压栈，当所扫描元素的优先级小于栈顶元素优先级的时候，利用while循环使栈顶元素逐
个出栈，直到栈顶元素的优先级小于所扫描元素优先级，所以我就以如下表达式
precede(exp[i],optr.data[optr.top])<=0为条件写了while循环，但出现了死
循环的情况，运行结果如下图
图 6 中缀转后缀时错误结果图
解决方法如下：
当所扫描元素的优先级小于栈顶元素的优先级时，栈顶元素要逐个出栈，如果只考
虑precede(exp[i],optr.data[optr.top])<=0这个条件的话，栈顶元素确实会逐
个出栈，比如输入8-4*3这样的表达式不会出错，但如果输入8-4+3或者4*3-3
这种表达式时就会出错，原因是当表达式为后者时，栈顶元素会全部出栈，从而
会出现操作符栈为空的情况，当操作符栈为空的情况下，栈中没有数值可以作为
实参传递给优先级比较函数，所以此时就没有优先级比较这个必要了，但条件中
没有体现出这个限制条件，所以只要遇到操作符栈会为空的这种情况，此时优先
级比较函数的返回总是为小于0的情况，所以就会出现死循环，所以要添加一个
必要的条件，正确条件为
while(precede(exp[i],optr.data[optr.top])<=0&&optr.top!=-1)此时就会输出
正确的结果。
●在直接计算时函数形式参数的定义,与传递有错误,具体描述如下：
在直接计算时，定义了一个基本的计算函数，根据实参传来递的操作符的种类，来
进行相应的运算，我就参考出栈函数pop（），以一个数值栈类型的变量和字符型
的变量为形参，编写了基本计算函数cal(ODStack *S,char c)，然后以栈名S对
传递过来的实参栈，进行相应的操作，但编译出现错误。
问题的解决方法如下：
在现在的知识范围内，不太了解以栈类型为形参的函数是如何进行传递的，是单向
值传递，还是像指针和数组那样，可以直接对实参里边的数值进行直接的更改，所
以避开了这一点，我以常用的类型的变量作为形参，所写函数如下
cal(double tem1,double tem2,char c)，前两个参数是计算所需的两个数，C是
操作符，操作数直接从数值栈中出栈然后以实参形式传递给tem1，tem2.然后函
《计算方法》课内实验报告
《计算方法》实验报告 姓名： 班级： 学号： 实验日期: 2011年10月26日
一、实验题目： 数值积分 二、实验目的： 1．熟悉matlab 编写及运行数值计算程序的方法。 2．进一步理解数值积分的基础理论。 3．进一步掌握应用不同的数值积分方法求解给定的积分并给出数据结果及误差分析。 三、实验内容： 1．分别用复合梯形求积公式及复合辛普森求积公式计算积分xdx x ln 10 ? , 要求计算精度达到410-,给出计算结果并比较两种方法的计算节点数. 2．用龙贝格求积方法计算积分dx x x ?+3 021,使误差不超过510-. 3．用3=n 的高斯-勒让德公式计算积分?3 1 sin x e x ,给出计算结果. 4．用辛普森公式(取2==M N ) 计算二重积分.5 .00 5 .00 dydx e x y ? ? - 四、实验结果： 1.（1）复合梯形法: 将区间[a,b]划分为n 等份，分点n k n a b h kh a x k ,2,1,0,,=-=+=在每个区间[1,+k k x x ](k=0,1,2,···n-1)上采用梯形公式，则得 )()]()([2)()(1 11 1 f R x f x f h dx x f dx x f I n n k k k b a n k x x k k ++===∑?∑? -=+-=+ 故)]()(2)([21 1 b f x f a f h T n k k n ++=∑-=称为复合梯形公式 计算步长和划分的区间 Eps=1E-4 h1=sqrt(Eps/abs(-(1-0)/12*1/(2+1))) h1 =0.0600 N1=ceil(1/h1) N1 =17 用复合梯形需要计算17个结点。 复合梯形： function T=trap(f,a,b,n) h=(b-a)/n;
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告 篇一：数据结构实验二——算术表达式求值实验报告 《数据结构与数据库》 实验报告 实验题目算术表达式求值 学院：化学与材料科学学院 专业班级：09级材料科学与工程系pb0920603 姓学 邮名：李维谷号：pb09206285箱： liwg@https://www.sodocs.net/doc/717254299.html,指导教师：贾伯琪 实验时间：20XX年10月10日 一、需要分析 问题描述： 表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析： 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。 在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。 算法规定： 输入形式：一个(:数据结构表达式求值实验报告)算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。 输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。 程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。 测试数据：正确输入：12*（3.6/3+4^2-1）#
利用栈实现c语言计算器
栈的应用：C实现简单计算器（表达式的计算） 作为栈的著名应用，表达式的计算可以用下面方法实现： 首先建立两个栈，操作数栈NUM_S和运算符栈OPR_S。 其中，操作数栈用来存储表达式中的操作数；运算符栈用来存储表达式中的运算符。可以用字符‘=’来表示表达式结束符。 自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W 做如下不同的处理： 1.若W为操作数，则将W压入操作数栈NUM_S，且继续扫描下一个字符； 2.若W为运算符，则根据运算符的性质做相应的处理： （0）若符号栈为空，无条件入栈当前指针指向的字符 （1）若w为不大于运算符栈栈顶的运算符，则从操作数栈NUM_S中弹出两个操作数，设先后弹出的操作数为a、b，再从运算符栈 OPR_S中弹出一个运算符，比如为+，然后作运算a+b,并将运算结果压入操作数栈NUM_S。 （2）若w为左括号或者运算符的优先级大于运算符栈栈顶的运算符，则将运算符W 压入运算符栈OPR_S，并继续扫描下一个字符。 （3）若运算符W为右括号，循环操作（设先后弹出的操作数为a、b，再从运算符栈OPR_S中弹出一个运算符，比如为+，然后作运 算a+b, 并将运算结果压入操作数栈NUM_S），直到从运算符栈中弹出第一个左括号。 （4）若运算符W为表达式结束符‘=’，循环操作（设先后弹出的操作数为a、b，再从运算符栈OPR_S中弹出一个运算符，比如为 +，然后作运算a+b, 并将运算结果压入操作数栈NUM_S），直到运算符栈为空为止。此时，操作数栈栈顶元素即为表达式的 值。 ====================================================================== === 举例：计算3+(5-2*3)/4-2= （1）开始栈为空，3入栈，+入栈，（无条件入栈，5入栈，-号优先级比（高，所以-号入栈，2入栈，*优先级比目前栈顶的-号优先级高，所以*入栈，3入栈，接着扫描到）括号，）括号不入栈 | | | | --------- ---------- | 3 | | * | --------- ---------- | 2 | | - |
太原理工大学数值计算方法实验报告
本科实验报告 课程名称：计算机数值方法 实验项目：方程求根、线性方程组的直接解 法、线性方程组的迭代解法、代数插值和最 小二乘拟合多项式 实验地点：行勉楼 专业班级： ******** 学号： ********* 学生姓名： ******** 指导教师：李誌，崔冬华 2016年 4 月 8 日
y = x*x*x + 4 * x*x - 10; return y; } float Calculate(float a,float b) { c = (a + b) / 2; n++; if (GetY(c) == 0 || ((b - a) / 2) < 0.000005) { cout << c <<"为方程的解"<< endl; return 0; } if (GetY(a)*GetY(c) < 0) { return Calculate(a,c); } if (GetY(c)*GetY(b)< 0) { return Calculate(c,b); } } }; int main() { cout << "方程组为：f(x)=x^3+4x^2-10=0" << endl; float a, b; Text text; text.Getab(); a = text.a; b = text.b; text.Calculate(a, b); return 0; } 2.割线法： // 方程求根（割线法）.cpp : 定义控制台应用程序的入口点。// #include "stdafx.h" #include"iostream"
心得体会 使用不同的方法，可以不同程度的求得方程的解，通过二分法计算的程序实现更加了解二分法的特点，二分法过程简单，程序容易实现，但该方法收敛比较慢一般用于求根的初始近似值，不同的方法速度不同。面对一个复杂的问题，要学会简化处理步骤，分步骤一点一点的循序处理，只有这样，才能高效的解决一个复杂问题。
数据结构实验二——算术表达式求值实验报告
《数据结构与数据库》 实验报告 实验题目 算术表达式求值 学院：化学与材料科学学院 专业班级：09级材料科学与工程系PB0920603 姓名：李维谷 学号：PB09206285 邮箱：liwg@https://www.sodocs.net/doc/717254299.html, 指导教师：贾伯琪 实验时间：2010年10月10日 一、需要分析 问题描述：
表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。 问题分析： 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。 在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。 算法规定： 输入形式：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。 输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。 程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。 测试数据：正确输入：12*（3.6/3+4^2-1）# 输出结果：194.4
c 计算器实验报告
简单计算器 姓名: 周吉祥 实验目的：模仿日常生活中所用的计算器，自行设计一个简单的计算器程序，实现简单的计算功能。 实验内容： (1)体系设计： 程序是一个简单的计算器，能正确输入数据，能实现加、减、乘、除等算术运算，运算结果能正确显示，可以清楚数据等。 (2)设计思路： 1)先在Visual C++ 6.0中建立一个MFC工程文件，名为 calculator. 2)在对话框中添加适当的编辑框、按钮、静态文件、复选框和单 选框 3)设计按钮，并修改其相应的ID与Caption. 4)选择和设置各控件的单击鼠标事件。 5)为编辑框添加double类型的关联变量m_edit1. 6)在calculatorDlg.h中添加math.h头文件，然后添加public成 员。 7)打开calculatorDlg.cpp文件，在构造函数中，进行成员初始 化和完善各控件的响应函数代码。 (3)程序清单：
●添加的public成员： double tempvalue; //存储中间变量 double result; //存储显示结果的值 int sort; //判断后面是何种运算：1.加法2.减法3. 乘法 4.除法 int append; //判断后面是否添加数字 ●成员初始化： CCalculatorDlg::CCalculatorDlg(CWnd* pParent /*=NULL*/) : CDialog(CCalculatorDlg::IDD, pParent) { //{{AFX_DATA_INIT(CCalculatorDlg) m_edit1 = 0.0; //}}AFX_DATA_INIT // Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); tempvalue=0; result=0; sort=0; append=0; }
数据结构算术表达式求值实验报告
软件技术基础实验报告 实验名称：表达式计算器 系别：通信工程 年级： 班级： 学生学号： 学生姓名： 《数据结构》课程设计报告 题目简易计算表达式的演示 【题目要求】 要求：实现基本表达式计算的功能 输入：数学表达式，表达式由整数和“+”、“-”、“×”、“/”、“（”、“）”组成输出：表达式的值 基本操作：键入表达式，开始计算，计算过程和结果记录在文档中 难点：括号的处理、乘除的优先级高于加减
1．前言 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 算法输入：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为简化，规定操作数只能为正整数，操作符为+、-*、/、=，用#表示结束。 算法输出：表达式运算结果。 算法要点：设置运算符栈和运算数栈辅助分析算符优先关系。在读入表达式的字符序列的同时，完成运算符和运算数的识别处理，以及相应运算。 2．概要设计 2.1 数据结构设计 任何一个表达式都是由操作符，运算符和界限符组成的。我们分别用顺序栈来寄存表达式的操作数和运算符。栈是限定于紧仅在表尾进行插入或删除操作的线性表。顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top 指示栈顶元素在顺序栈中的位置，base 为栈底指针，在顺序栈中，它始终指向栈底，即top=base 可作为栈空的标记，每当插入新的栈顶元素时，指针top 增1，删除栈顶元素时，指针top 减1。 2.2 算法设计 为了实现算符优先算法。可以使用两个工作栈。一个称为OPTR ，用以寄存运算符，另一个称做OPND ，用以寄存操作数或运算结果。 1.首先置操作数栈为空栈，表达式起始符”#”为运算符栈的栈底元素； 2.依次读入表达式，若是操作符即进OPND 栈，若是运算符则和OPTR 栈的栈顶运算符比较优先权后作相应的操作，直至整个表达式求值完毕（即OPTR 栈的栈顶元素和当前读入的字符均为”#”）。 2.3 ADT 描述 ADT Stack{ 数据对象：D={ i a |i a ∈ElemSet,i=1,2,…，n, n ≧0} 数据对象：R1={< 1 ,-i i a a >| 1-i a ,D a i ∈,i=2,…，n}
计算方法实验报告格式
计算方法实验报告格式 小组名称: 组长姓名(班号)： 小组成员姓名(班号): 按贡献排序情况: 指导教师评语: 小组所得分数: 一个完整的实验，应包括数据准备、理论基础、实验内容及方法，最终对实验结果进行分析，以达到对理论知识的感性认识，进一步加深对相关算法的理解，数值实验以实验报告形式完成，实验报告格式如下： 一、实验名称 实验者可根据报告形式需要适当写出． 二、实验目的及要求 首先要求做实验者明确，为什么要做某个实验，实验目的是什么，做完该实验应达到什么结果，在实验过程中的注意事项，实验方法对结果的影响也可以以实验目的的形式列出． 三、算法描述（实验原理与基础理论） 数值实验本身就是为了加深对基础理论及方法的理解而设置的，所以要求将实验涉及到的理论基础，算法原理详尽列出． 四、实验内容 实验内容主要包括实验的实施方案、步骤、实验数据准备、实验的算法以及可能用到的仪器设备． 五、程序流程图 画出程序实现过程的流程图，以便更好的对程序执行的过程有清楚的认识，在程序调试过程中更容易发现问题． 六、实验结果 实验结果应包括实验的原始数据、中间结果及实验的最终结果，复杂的结果可以用表格
形式列出，较为简单的结果可以与实验结果分析合并出现． 七、实验结果分析 实验结果分析包括对对算法的理解与分析、改进与建议． 数值实验报告范例 为了更好地做好数值实验并写出规范的数值实验报告，下面给出一简单范例供读者参考． 数值实验报告 小组名称: 小组成员(班号): 按贡献排序情况: 指导教师评语: 小组所得分数: 一、实验名称 误差传播与算法稳定性． 二、实验目的 1．理解数值计算稳定性的概念． 2．了解数值计算方法的必要性． 3．体会数值计算的收敛性与收敛速度． 三、实验内容 计算dx x x I n n ? += 1 10 ，1,2,,10n = ． 四、算法描述 由 dx x x I n n ? += 1 10 ，知 dx x x I n n ?+=--101110，则
算术表达式语法检查实验报告
中南民族大学计算机科学学院本科课程设计 任务书 设计名称：算术表达式语法检查 指导教师：下达时间： 2015-5-8 学生姓名：学号： 专业： 一、课程设计的基本要求 根据所学知识，编写指定题目的C++语言程序，并规范地完成课程设计报告。通过课程设计，加深对《C++面向对象程序设计》课程所学知识的理解，熟练掌握和巩固C++语言的基本知识和语法规范，掌握C++语言的基础知识，理解面向对象系统的封装性、继承性和多态性；熟练使用C语言中的函数、数组、指针、链表和字符串等基本知识；掌握类的定义、标准String类和向量；理解掌握友元函数和重载操作符，动态数组；理解掌握继承和多态性；掌握模版的使用；能够进行程序调试过程中的异常处理；进一步掌握利用C++进行类的定义和操作方法；进一步掌握类的继承和派生方法；进一步理解虚函数和多态；综合利用上述知识，学习设计并编写面向对象的C++简单应用程序；培养解决复杂任务功能分解方法（自顶向下逐步求精、模块化设计、信息隐藏等）。 学会编制结构清晰、风格良好、数据结构适当的C++语言程序，从而具备利用计算机编程分析解决综合性实际问题的初步能力。 具体要求如下： 1、采取模块化方式进行程序设计，要求程序的功能设计、数据结构设计及整体结构设计合理。学生也可根据自己对题目的理解增加新的功能模块（视情况可另外加分）。 2、系统以菜单界面方式（至少采用文本菜单界面，如能采用图形菜单界面更好）工作，运行界面友好，演示程序以用户和计算机的对话方式进行。 3、程序算法说明清晰，理论分析与计算正确，运行情况良好，实验测试数据无误，容错性强（能对错误输入进行判断控制）。 4、编程风格良好（包括缩进、空行、适当注释、变量名和函数名见名知意，程序容易阅读等）； 5、写出规范的课程设计报告，具体要求见相关说明文档。
四则运算表达式求值实验报告
HUNAN UNIVERSITY 课程实习报告 题目：四则运算表达式求值 学生姓名： 学生学号： 专业班级： 指导老师： 完成日期：
一、需求分析 四则运算表达式求值，将四则运算表达式用中缀表达式表示，然后转换为后缀表达式，并计算结果。 本程序要求利用二叉树后序遍历来实现表达式的转换，同时可以使用实验2的结果来求解后缀表达式的值。 在字符界面上输入一个中缀表达式，回车表示结束。如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。 测试数据 输入： 21+23*（12-6） 输出： 21 23 12 6 -*+ 二、详细设计 输入和输出的格式 输入 本程序可以将输入的四则运算表达式（中缀表达式）转换为后缀表达式 输出 后缀表达式为：//输出结果的位置 表达式的值为：//输出结果的位置 三、调试分析 本次实验的难点主要是在建立二叉树的问题上。关于如何把中缀表达式存入二叉树中，我参考了网上的一些方法，成功实现了目标，但是却遇到了一个问题，那就是不能处理小数，甚至两位或两位以上的整数。因为如果采用字符数组来存储操作数，运算符合一位整数还可以处理，但对于两位数就就会出问题，最后我改进采用字符串数组来存储操作数，成功解决了问题。 另外在处理输入的非法表达式问题中，我也费了很大功夫，但总体问题不大。 四、测试结果 五、用户使用说明（可选） 1、运行程序时 提示输入四则运算表达式 本程序可以将中缀表达式转化为后缀表达式，并计算结果 请输入四则运算表达式： 输出 后缀表达式为： 表达式的值为： 程序源代码（c++） #include
利用栈求表达式的值,可供小学生作业,并能给出分数 数据结构课程设计说明书格式
中北大学 数据结构 课程设计说明书 2011年12月20日
1. 设计任务概述（包括系统总体框图及功能描述） 此课题是研究表达式求值的问题，以帮助小学生完成测试。为了达到这个功能，实际我们要做的就是出题，和计算分数给出评价的工作。整体设计都是以这个要求为轴心进行的。为了直观和方便，现画出软件整体设计模块图。 整体设计模块图可以清晰的看出软件的几大模块。整个系统的操作流程图可以看出操作的整体流程，如下图 2.
根据以上功能说明，设计运算信息，堆栈的存储结构，设计程序完成功能； 3. 功能模块详细设计 在此说明每个部分的算法设计说明（可以是描述算法的流程图），每个程序中使用的存储结构设计说明（如果指定存储结构请写出该存储结构的定义）。 3.1 详细设计思想 学生要进行测试，首先要有试题。那么我们就要先建立试题库。这个试题库的试题是我们在程序运行过程中手动输入，存放在一个shujuku.txt的文件中。 首先在主函数中调用创建试题库函数，将试题存入到试题库文件shitiku.txt中，然后将该调用从主函数中删除。 创建试题库函数：创建指向xuanti类型的指针，利用循环将输入的测试题该指针的xuanti单元中，最后将该指针中的测试题写入试题库文件shitiku.txt中。 3.2 核心代码 (正文宋体小四号字，1.5倍行距) #include
(完整版)数学表达式计算(c语言实现)
一、设计思想 计算算术表达式可以用两种方法实现： 1.中缀转后缀算法 此算法分两步实现：先将算术表达式转换为后缀表达式，然后对后缀表达式进行计算。具体实现方法如下： （1）中缀转后缀 需要建一个操作符栈op和一个字符数组exp，op栈存放操作符，字符数组用来存放转换以后的后缀表达式。首先，得到用户输入的中缀表达式，将其存入str数组中。 对str数组逐个扫描，如果是数字或小数点，则直接存入exp数组中，当扫描完数值后，在后面加一个#作为分隔符。 如果是操作符，并且栈为空直接入栈，如果栈不为空，与栈顶操作符比较优先等级，若比栈顶优先级高，入栈；如果比栈顶优先级低或相等，出栈将其操作符存到exp数组中，直到栈顶元素优先等级低于扫描的操作符，则此操作符入栈；如果是左括号，直接入栈，如果是右括号，出栈存入exp数组，直到遇到左括号，左括号丢掉。然后继续扫描下一个字符，直到遇到str中的结束符号\0，扫描结束。结束后看op栈是否为空，若不为空，继续出栈存入exp数组中，直到栈为空。到此在exp数组最后加结束字符\0。 我们就得到了后缀表达式。 （2）后缀表达式计算 此时需要一个数值栈od来存放数值。对exp数组进行逐个扫描，当遇到数字或小数点时，截取数值子串将其转换成double类型的小数，存入od栈中。当遇到操作符，从栈中取出两个数，进行计算后再放入栈中。继续扫描，知道扫描结束，此时值栈中的数值就是计算的结果，取出返回计算结果。 2.两个栈实现算法 此算法需要两个栈，一个值栈od，一个操作符栈op。将用户输入的数学表达式存入str数组中，对其数组进行逐个扫描。 当遇到数字或小数点，截取数值子串，将其转换成double类型的数值存入od栈中； 当遇到左括号，直接入op栈；遇到右括号，op栈出栈，再从值栈od中取出两个数值，计算将其结果存入值栈中，一直进行此操作，直到操作符栈栈顶为左括号，将左括号丢掉。 如果遇到操作符，若op栈为空，直接入栈；若栈不为空，与栈顶元素比较优先等级，若比栈顶操作符优先等级高，直接入op栈，如果低于或等于栈顶优先等级，op栈出栈，再从值栈中取出两个数值，计算将其结果存入值栈中，一直进行此操作，直到栈顶优先等级低于扫描的操作符等级，将此操作符入op栈。继续扫描直到遇到str中的结束字符\0，扫描结束。此时看操作符栈是否为空，若不为空，出栈，再从值栈中取出两个数值进行计算，将其结果存入值栈，一直进行此操作，直到操作符栈为空。此时把值栈中的数值取出，即为所得的最终计算结果。 二、算法流程图 第一种算法：中缀转后缀算法
计算方法实验报告 拟合
南京信息工程大学实验（实习）报告 一、实验目的: 用最小二乘法将给定的十个点拟合成三次多项式。 二、实验步骤： 用matlab编制以函数为基的多项式最小二乘拟合程序，并用于对下列数据作三次多项式最小二乘拟合(取权函数wi=1) x -2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 y -2.30 -1 -0.14 -0.25 0.61 1.03 1.75 2.75 4.42 6.94 给定直线方程为：y=1/4*x3+1/2*x2+x+1 三、实验结论： 最小二乘法：通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法还可用于曲线拟合。 一般地。当测量数据的散布图无明显的规律时，习惯上取n次代数多项式。 程序运行结果为： a = 0.9731 1.1023 0.4862 0.2238 即拟合的三次方程为：y=0.9731+1.1023x+0.4862*x2+0.2238*x3
-2.5 -2-1.5-1-0.5 00.51 1.52 2.5 -4-20246 81012 x 轴 y 轴 拟合图 离散点 y=a(1)+a(2)*x+a(3)*x.2+a(4)*x.3 结论： 一般情况下，拟合函数使得所有的残差为零是不可能的。由图形可以看出最小二乘解决了残差的正负相互抵消的问题，使得拟合函数更加密合实验数据。 优点：曲线拟合是使拟合函数和一系列的离散点与观测值的偏差平方和达到最小。 缺点：由于计算方法简单，若要保证数据的精确度，需要大量的数据代入计算。
利用栈求表达式的值
数据结构课程设计 姓名：杨颂敬 班级：软件0901班 学号：0930*******
目录： 1．需求分析 (1) 2．概要设计 (1) 3．详细设计................................. 3-6 4．调试分析................................. 6-8 5．用户使用说明 (8) 6．测试结果 (9) 7．附录 (9)
利用栈求表达式的值，可供小学生作业，并 能给出分数。 1．需求分析 任务：通过此系统可以实现如下功能： 此系统能够输入一个表达式，并计算该表达式的值。可以根据计算结果给出分数。能供小学生进行简单的四则运算，此外这里特别强调括号的匹配！ 要求： 根据以上功能说明，设计运算信息，堆栈的存储结构，设计程序 完成功能； 2. 概要设计 在此说明每个部分的算法设计说明（可以是描述算法的流程图），每个程序中使用的存储结构设计说明（如果指定存储结构请写出该存储结构的定义）。 主菜单
3．详细设计 #include "string.h" #include "stdio.h" #include"conio.h" #define maxsize 100 #include "ctype.h" typedef char datatype; typedef struct { datatype stack[maxsize]; int top; } seqstack; void stackinitiate(seqstack *s) { s->top=0; } int stacknotempty(seqstack s) { if(s.top<=0) return 0; else return 1; } int stackpush(seqstack *s, datatype x) { if(s->top>=maxsize) { printf("堆栈已满无法插入!\n"); return 0; } else { s->stack[s->top]=x; s->top++; return 1; } } int stackpop(seqstack *s,datatype *d) { if(s->top<=0) {
表达式求值实验报告
淮海工学院计算机工程学院 课程设计报告 设计名称：数据结构课程设计 选题名称：表达式求值 姓名：学号： 专业班级： 系（院）：计算机工程学院 设计时间： 设计地点：软件工程实验室、教室 指导教师评语： 成绩： 签名： 年月日
1．课程设计目的 1、训练学生灵活使用所学数据结构知识，独立完成问题分析，结合数据结构理论知识，编写程序求解指定问题。 2.初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能； 3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力； 4.训练用系统的观点和软件开发一般规范进行软件开发，巩固、深化学生的理论知识，提高编程水平，并在此过程中培养他们严谨的科学态度和良好的工作作风。 2．课程设计任务和要求： 任务 根据教材《数据结构-C语言描述》（耿国华主编）和参考书《数据结构题集（C语言版）》（严蔚敏、吴伟民主编）选择课程设计题目，要求通过设计，在数据结构的逻辑特性和物理表示、数据结构的选择使用、算法的设计及其实现等方面加深对课程基本内容的理解和综合运用。 设计题目从任务书所列选题表中选取，每班每题不得超过2人。 学生自选课题 学生原则上可以结合个人爱好自选课题，要求课题有一定的深度和难度，有一定的算法复杂性，能够巩固数据结构课程所学的知识。学生自选课题需在18周前报课程设计指导教师批准方可生效。 要求： 1、在处理每个题目时，要求从分析题目的需求入手，按设计抽象数据类型、构思算法、通过设计实现抽象数据类型、编制上机程序和上机调试等若干步骤完成题目，最终写出完整的分析报告。前期准备工作完备和否直接影响到后序上机调试工作的效率。在程序设计阶段应尽量利用已有的标准函数，加大代码的重用率。 2、.设计的题目要求达到一定工作量（300行以上代码），并具有一定的深度和难度。 3、程序设计语言推荐使用C/C++，程序书写规范，源程序需加必要的注释; 4、每位同学需提交可独立运行的程序； 5 、每位同学需独立提交设计报告书（每人一份），要求编排格式统一、规范、内容充实，不少于10页（代码不算）； 6、课程设计实践作为培养学生动手能力的一种手段，单独考核。 3．课程设计说明书
带括号的四则运算表达式的求值栈实现
带括号的四则运算表达式的求值（栈实现） 利用栈这种数据结构来实现一个加减乘除以及带括弧的混合数学表达式的计算，对于数学表达式的计算，可以设置一个运算符栈和一个数字栈，分别来保存运算符、数字或者中间计算得到的结果。将整个表达式看做一个字符串，从开头依次判断每个字符是运算符还是数字，若是运算符，则根据运算符优先级来确定是将其压栈还是弹栈进行计算；若是数字，则先将其转化并计入一个临时double型变量中，看下一个字符是否为运算符栈，若是，则将临时变量压进数字栈，否则读取下一个数字字符并进行相关处理后累加到临时变量中，直到下一个字符为运算符，将临时变量压进数字栈。最后，当字符为"="时，结束计算，得到计算结果。本算法需要先设置一个运算符优先级表，下表可供参考： +-*/()= +>><<<>> ->><<<>> *>>>><>> />>>><>> (<<<<<= )>>>>?>> =<<<<
while(!IsOper(s[j])) { { point = 10; j++; continue; } if(!point)? 5 - 7 / 2 + 3. - .1 1 + 2 / ( 2 - / ) - 3 2 * ( ( 3 + 2 ) - 3 */ 本代码生成的程序，在输入表达式时，数字与运算符之间可以有若干空格或者没有；对于小数，可以没有整数部分（即小数点之前没有数字），也可以没有小数部分（即小数点之后没有数字）；表达式可以为无效表达式（如括号不匹配或者出现除数为0的情况等）；如以上的样例输入。对于以上样例输入，其对应输出结果为： The divisor cannot be zero! The parentheses do not match!
C语言程序设计实验报告实验数据类型运算符和表达式
凯里学院C 语言程序设计实验报告 ×××××专业××年级××班，学号××××××姓名××成绩 合作者实验日期年月日 指导教师评阅日期年月日 实验二数据类型、运算符和表达式 一、实验目的： （1）掌握C 语言数据类型，熟悉如何定义一个整型、字符型、实型变量、以及对它们赋值的方法，了解以上类型数据输出时所用的格式转换符。 （2）学会使用C 的有关算术运算符，以及包含这些运算符的表达式，特别是自加（++）和自减（――）运算符的使用。 （3）掌握C 语言的输入和输出函数的使用 （4）进一步熟悉C 程序的编辑、编译、连接和运行的过程，学会使用stepbystep 功能。 （5）认真阅读教材数据类型，算术运算符和表达式，赋值运算符和表达式部分内容。 二、实验内容： (1)输人并运行下面的程序 #include
printf("%c%c\n",c1,c2); } （2）按习题3.7的要求编程序并上机运行 该题的要求是: 要将“China”译成密码，密码规律是:用原来字母后面的第4个字母代替原来的字母。 例如，字母“A”后面第4个字母是“E”，用“E”代替“A”。因此，“China”应译为“Glmre"。 请编一程序，用赋初值的方法使。cl，c2，c3，c4，c5五个变量的值分别为‘C’、‘h’、‘i’、‘n’、‘a’，经过运算，使cl，c2，c3，c4，c5分别变为‘G’、‘l’、‘m’、‘r’、‘e’，并输出。 三、实验步骤： (1)输人并运行下面的程序 #include
利用栈求表达式的值,可供小学生作业,并能给出分数
//1.h #include
class link { public: void Push(Stack
算术表达式求值-数据结构实验报告
清华大学数据结构课程实验报告（20 -20 学年第学期） 报告题目：算术表达式求值 任课老师： 专业： 学号： 姓名： 二0一年月日
摘要：现代科学技术高速发展，各种高科技产品频频问世，而各种技术的基础都离不开基本的表达式求值，它虽然简单，但却是任何复杂系统的基本执行操作。栈是一种重要的线性结构，从数据结构的角度看，它是一种特殊的线性表，具有先入先出的特点。而算符优先法的设计恰巧符合先入先出的思想。故我们基于栈这种数据结构，利用算符优先法，来实现简单算术表达式的求值。 关键字：算符优先法；算术表达式；数据结构；栈 一、课题概述 1、问题描述 一个算术表达式是由运算数、运算符、界限符组成。假设操作数是正整数，运算符只含有加“+”、减“-”、乘“*”、除“/”四种二元运算符，界限符有左括号“（”、右括号“）”和表达式起始、结束符“#”。利用算符优先法对算术表达式求值。 2、设计目的 （1）通过该算法的设计思想，熟悉栈的特点和应用方法； （2）通过对算符优先法对算术表达式求值的算法执行过程的演示，理解在执行相应栈的操作时的变化过程。 （3）通过程序设计，进一步熟悉栈的基本运算函数； （4）通过自己动手实现算法，加强从伪码算法到C语言程序的实现能力。3、基本要求： （1）使用栈的顺序存储表示方式； （2）使用算符优先法； （3）用C语言实现； （4）从键盘输入一个符合要求的算术表达式，输出正确的结果。 4、编程实现平台 Microsoft Visual C++ 6.0 二、设计思路及采取方案 1、设计思路： 为了实现算符优先法，可以使用两个工作栈。一个称做OPTR，用以寄存运
利用栈实现多项式的计算,
/*************************** //利用栈实现多项式的计算， //如输入: 3*(7-2)# //输出：3*(7-2)#=15 //清华大学——数据结构——53页 ****************************/ // v4.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include
/*************************** //取栈顶元素 ****************************/ ElemTypeGetTop(Stack s) { return ( *(s.top - 1)); } /*************************** //压栈 ****************************/ void Push(Stack &s, ElemType e) { * s.top ++ = e; } /*************************** //弹栈 ****************************/ void Pop(Stack &s, ElemType& e) { e = * -- s.top; } #define OPSETSIZE 7 unsigned char prior[7][7] = { '>','>','<','<','<','>','>', '>','>','<','<','<','>','>', '>','>','>','>','<','>','>', '>','>','>','>','<','>','>', '<','<','<','<','<','=',' ', '>','>','>','>',' ','>','>', '<','<','<','<','<',' ','=' }; char OPSET1[7] = {'+', '-' , '*' , '/' ,'(' , ')' , '#'}; /******************************************************
实验四 栈的应用---算术表达式的计算
浙江大学城市学院实验报告 课程名称数据结构与算法 实验项目名称实验四栈的应用---算术表达式的计算 学生姓名专业班级学号 实验成绩指导老师（签名）日期 一.实验目的和要求 1．进一步掌握栈的基本操作的实现。 2．掌握栈在算术表达式的计算方面的应用。 二. 实验内容 1.编写程序对后缀表达式进行求值（利用栈），即从键盘输入任一个后缀表达式，输出该后缀表达式的值。要求：把栈的基本操作的实现函数存放在文件stack.h中，在主程序文件test4.cpp中包含后缀表达式求值函数double Compute(char *str)与主函数。 2．填写实验报告，实验报告文件取名为report4.doc。 3．上传实验报告文件report4.doc与源程序文件stack.h及test4.cpp到Ftp服务器上你自己的文件夹下。 三. 函数的功能说明及算法思路 包括每个函数的功能说明，及一些重要函数的算法实现思路 四. 实验结果与分析 包括运行结果截图等
五. 心得体会 记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。 看着书写，问题不大。自己写可能会漏写一些情况。 【附录----源程序】 Test4.cpp #include
相关文档
- 利用栈求表达式的值,可供小学生作业,并能给出分数 数据结构课程设计说明书格式
- 数据结构课程设计--利用栈求表达式的值-可供小学生作业-并能给出分数
- 长沙理工大学数据结构栈的实现及应用算术表达式求值实验报告
- 利用栈求表达式的值,可供小学生作业任务,并能给出分数数据结构教学规划使用说明格式
- 利用栈实现c语言计算器
- 栈---实现表达式计算(完整)
- 利用栈求表达式的值,可供小学生作业,并能给出分数
- 长沙理工大学数据结构栈的实现及应用算术表达式求值实验报告
- 数据结构C语言版_栈实现表达式求值
- 用堆栈实现表达式计算
- 基于顺序栈实现的四则算术表达式计算
- 四则运算表达式求值(栈+二叉树,c++版)
- 栈的应用：表达式求值1
- 用堆栈实现表达式的求解
- 用栈实现表达式计算
- c语言中缀后缀算术表达式求值用栈实现
- 利用栈求表达式的值
- 利用栈实现表达式求值
- 用栈实现表达式计算
- 长沙理工大学数据结构栈的实现及应用算术表达式求值实验报告