表达式的直接计算 C语言版

合集下载

算术表达式的计算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语言中最基础的计算方式之一。

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

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

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

(完整版)数学表达式计算(c语言实现)

(完整版)数学表达式计算(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 栈。

c语言表达式运算

c语言表达式运算

c语言表达式运算1.引言1.1 概述概述部分旨在介绍C语言表达式运算的基本概念和重要性。

在C语言中,表达式运算是程序中最基本、最常用的操作之一。

通过对表达式的运算,程序能够实现各种功能和逻辑判断。

C语言的表达式由操作数和运算符组成,通过特定的运算符以及它们的优先级和结合性,可以实现算术运算、逻辑运算、位运算和条件运算等各种类型的运算。

C语言表达式运算的结果是一个值,这个值可以被赋给变量,或者用于控制程序的流程。

表达式运算在编程中起着举足轻重的作用。

它可以用于简单的数值计算,例如加减乘除等算术运算。

同时,表达式运算也是实现复杂逻辑判断的基础,例如比较运算、逻辑运算和条件运算。

C语言的表达式运算还可以用于位运算,对二进制数值的位进行操作,实现各种位操作的需求。

了解和掌握表达式运算在C语言中的特性和规则,对于进行程序设计和算法实现至关重要。

在编写高效、可靠且易于理解的代码时,正确使用表达式运算符,合理选择表达式的结构和运算次序,都是必不可少的。

同时,对于程序调试和错误排除也有着重要的作用,通过对表达式运算过程的观察和分析,可以帮助我们找出代码中隐藏的错误和逻辑漏洞。

总之,C语言的表达式运算是程序设计中的重要组成部分,它涵盖了各种运算类型,能够帮助我们实现各种功能和逻辑判断。

深入理解和掌握表达式运算的特性和规则,对于编写高质量的代码和实现优化的算法来说是至关重要的。

在接下来的部分中,我们将详细介绍表达式的基本概念和运算符,并通过实例来展示其在实际编程中的应用。

1.2文章结构文章结构部分的内容应该包括对于整篇文章的组织和布局的介绍。

下面是一个可能的写作内容示例:在本文中,我们将按照以下结构来进行讨论和分析C语言表达式的运算。

文章主要包含三个部分:引言、正文和结论。

在引言部分,我们将对本文要探讨的主题进行概述,简要介绍C语言表达式运算的背景和基本概念,并明确文章的目的。

通过引言,读者可以对本文的主题和目标有一个初步的了解。

C语言程序设计(三)简单的算术运算和表达式

C语言程序设计(三)简单的算术运算和表达式

C语⾔程序设计(三)简单的算术运算和表达式第三章简单的算术运算和表达式算数运算符:⼀元、⼆元、三元(条件运算符)1/2是整型除法,1.0/2是浮点数除法求余运算(%)限定参与运算的两个操作数必须为整数,不能对两个实型数据进⾏求余运算余数的符号与被除数的符号相同C语⾔中没有幂运算符!//L3-1#include <stdio.h>main(){int x = 153, b0, b1, b2, sum;b2 = x / 100; /* 计算百位数字 */b1 = (x - b2 * 100) / 10; /* 计算⼗位数字 */b0 = x % 10; /* 计算个位数字 */sum = b2 + b1 + b0;printf("b2=%d, b1=%d, b0=%d, sum=%d\n", b2, b1, b0, sum);}//运⾏结果b2=1, b1=5, b0=3, sum=9复合的赋值运算符+=:a+=b; 等价于 a=a+b;-=*=/=%=增1和减1运算符(⼀元运算符)++x:前缀运算符,在变量使⽤之前对其执⾏加1操作m=++n; 等价于 n=n+1;m=n;x++:后缀运算符,先使⽤变量的当前值,然后对其进⾏加1操作m=n++; 等价于 m=n;n=n+1;良好的程序设计风格提倡在⼀⾏语句中⼀个变量最多只出现⼀次增1或者减1运算不建议在程序中使⽤复杂的增1和减1运算符,过多的增1和减1运算符会导致程序的可读性变差宏常量和宏替换//L3-2#include <stdio.h>main(){double r = 5.3; /* 圆的半径 */printf("circumference = %f\n", 2*3.14159*r);printf("area = %f\n", 3.14159*r*r);}//运⾏结果circumference = 33.300854area = 88.247263//L3-3#include <stdio.h>main(){double r;printf("Input r:"); /* 提⽰⽤户输⼊半径的值*/scanf("%lf", &r); /* 以双精度实型格式从键盘输⼊半径的值 *///scanf()函数也是C的标准输⼊/输出函数//&称为取地址运算符,&r指定了⽤户输⼊数据存放的变量的地址printf("circumference = %f\n", 2*3.14159*r);printf("area = %f\n", 3.14159*r*r);}//运⾏结果Input r:6circumference = 37.699080area = 113.097240幻数:在程序中直接使⽤的常数导致程序的可读性变差容易发⽣书写错误难以修改把幻数定义为宏常量或const常量,⽤⼀个简单易懂的名字来代替⼀个长字符串能提⾼程序的可读性//L3-4#include <stdio.h>#define PI 3.14159 /* 定义宏常量PI */main(){double r;printf("Input r:");scanf("%lf", &r);printf("circumference = %f\n", 2*PI*r); /*编译时PI被替换为3.14159*/printf("area = %f\n", PI*r*r); /*编译时PI被替换为3.14159*/}宏定义中的标识符被称为宏名习惯上⽤字母全部⼤写的单词来命名宏常量将程序中出现的宏名替换为字符串的过程称为宏替换宏定义的宏名与字符串之间可有多个空⽩符,⽆需加等号字符串后不以分号结尾宏定义不是C语句,⽽是⼀种编译预处理命令宏常量没有数据类型,const常量可以声明数据类型//L3-5#include <stdio.h>main(){const double PI = 3.14159; /* 定义实型的const常量PI */double r;printf("Input r:");scanf("%lf", &r);printf("circumference = %f\n", 2*PI*r);printf("area = %f\n", PI*r*r);}表达式中的⾃动类型转换:C编译器在对操作数进⾏运算之前将所有操作数都转换为取值范围较⼤的操作数类型,称为类型提升。

C语言中的运算符和表达式

C语言中的运算符和表达式

C语言中的运算符和表达式C语言是一种常用于系统编程和应用程序开发的程序设计语言,掌握C语言的运算符和表达式是学习C语言编程的基础之一。

在本文中,我们将深入探讨C语言中的运算符和表达式。

1. 算术运算符在C语言中,算术运算符用于执行基本的算术运算。

常见的算术运算符包括加法运算符(+)、减法运算符(-)、乘法运算符(*)、除法运算符(/)和取余运算符(%)。

这些运算符可用于对整数和浮点数执行常见的算术操作。

2. 关系运算符关系运算符用于比较两个值之间的关系。

常见的关系运算符包括等于运算符(==)、不等于运算符(!=)、大于运算符(>)、小于运算符(<)、大于等于运算符(>=)和小于等于运算符(<=)。

关系运算符通常用于条件语句和循环结构中,帮助程序根据比较结果做出相应的决策。

3. 逻辑运算符逻辑运算符用于对布尔表达式进行操作。

常见的逻辑运算符包括逻辑与运算符(&&)、逻辑或运算符(||)和逻辑非运算符(!)。

逻辑运算符常用于控制语句中,帮助程序根据多个条件判断结果做出适当的响应。

4. 位运算符位运算符用于对二进制数的位进行操作。

常见的位运算符包括按位与运算符(&)、按位或运算符(|)、按位异或运算符(^)和按位取反运算符(~)。

位运算符通常与位运算结合使用,用于处理二进制数据和位掩码。

5. 赋值运算符赋值运算符用于将一个值赋给变量。

常见的赋值运算符为等号(=),可以将右侧的表达式的值赋给左侧的变量。

此外,C语言还提供了一些复合赋值运算符,如加等(+=)、减等(-=)、乘等(*=)和除等(/=),用于简化赋值表达式的编写。

6. 运算符优先级在C语言中,不同的运算符具有不同的优先级。

了解运算符的优先级可以帮助我们正确地理解和编写表达式。

在复杂的表达式中,可以使用括号来改变运算符的优先级,以确保表达式的计算顺序符合我们的预期。

7. 表达式求值在C语言中,运算符和操作数组合形成表达式。

c语言 表达式

c语言 表达式

c语言表达式C语言表达式的使用在编程中起着至关重要的作用。

表达式是由操作数和操作符组成的,它们通过运算符进行运算并产生一个结果。

在本文中,我将介绍一些常见的C语言表达式,并探讨它们在实际编程中的应用。

我们来看一下赋值表达式。

赋值表达式用于将一个值赋给一个变量。

例如,x = 5; 这个表达式将5赋值给变量x。

赋值表达式在很多情况下都会被使用,比如初始化变量、更新变量的值等。

接下来,我们来看一下算术表达式。

算术表达式使用算术运算符对操作数进行运算。

常见的算术运算符包括加法、减法、乘法和除法。

例如,x + y 表示x和y的和,x - y 表示x和y的差。

算术表达式在计算中常常被使用,它们可以用于实现各种数学运算,如求和、求平均值等。

除了算术表达式,逻辑表达式也是C语言中非常重要的一种表达式。

逻辑表达式用于判断两个条件是否成立,并产生一个布尔值(真或假)。

常见的逻辑运算符包括与(&&)、或(||)和非(!)。

例如,x > 0 && x < 10 表示x大于0并且小于10。

逻辑表达式在条件判断和循环结构中广泛使用,它们可以用于实现复杂的逻辑判断和控制流程。

除了上述的基本表达式,C语言还提供了一些特殊的表达式,如条件表达式、位运算表达式和函数调用表达式等。

条件表达式是由三个操作数和两个运算符组成的,它根据条件的成立与否来选择返回其中之一的值。

位运算表达式用于对二进制位进行运算,常见的位运算符有与(&)、或(|)和异或(^)。

函数调用表达式用于调用函数并获取函数的返回值。

在实际编程中,我们经常会使用多个表达式来实现复杂的功能。

例如,我们可以使用赋值表达式将一个变量的值赋给另一个变量,然后使用算术表达式对变量进行计算,最后使用条件表达式进行判断并执行相应的操作。

通过合理地组合和使用表达式,我们可以实现各种复杂的功能和算法。

总结起来,C语言表达式是编程中非常重要的一部分,它们用于实现各种计算和判断。

数据结构课程设计四则运算表达式求值(C语言版)

数据结构课程设计四则运算表达式求值(C语⾔版) 明⼈不说暗话,直接上,输⼊提取码z3fy即可下载。

⽂件中包含程序,程序运⾏⽂件,设计报告和测试样例,应有尽有,欢迎⼩伙伴们在中下载使⽤。

本课程设计为四则运算表达式求值,⽤于带⼩括号的⼀定范围内正负数的四则运算标准(中缀)表达式的求值。

注意事项:1、请保证输⼊的四则表达式的合法性。

输⼊的中缀表达式中只能含有英⽂符号“+”、“-”、“*”、“/”、“(”、“)”、“=”、数字“0”到“9”以及⼩数点“.”,输⼊“=”表⽰输⼊结束。

例如9+(3-1)*3.567+10/2=,特别是请勿输⼊多余空格和中⽂左右括号。

2、输⼊的中缀表达式默认限定长度是1001,可根据具体情况调整字符串数组的长度。

3、请保证输⼊的操作数在double数据类型范围内,单个数字有效数字长度不可超过15位。

本课程设计中操作数是C语⾔中的双精度浮点数类型。

4、本课程设计中的运算数可以是负数,另外如果是正数可直接省略“+”号(也可带“+”号)。

 下⾯的程序正常运⾏需要在上⾯的百度⽹盘中下载相应⽂件,否则⽆法正常使⽤哦。

1/*本程序为四则运算表达式求值系统,⽤于计算带⼩括号的四则运算表达式求值。

2具体算法:3先将字符串处理成操作单元(操作数或操作符),再利⽤栈根据四则运算4的运算法则进⾏计算,最后得出结果。

*/56 #include<stdio.h>7 #include<ctype.h>8 #include<stdlib.h>9 #include<string.h>10 #include<stdlib.h>11 #include<ctype.h>1213const int Expmax_length = 1001;//表达式最⼤长度,可根据适当情况调整14struct Ope_unit15 {//定义操作单元16int flag;//=1表⽰是操作数 =0表⽰是操作符 -1表⽰符号单元17char oper;//操作符18double real;//操作数,为双精度浮点数19 };2021void Display();//菜单22void Instru(); //使⽤说明23int Check(char Exp_arry[]);24void Evalua(); //先调⽤Conver操作单元化,再调⽤Calculate函数计算结果并输出25int Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[]);//将字符串处理成操作单元26int Isoper(char ch);//判断合法字符(+ - * / ( ) =)27int Ope_Compar(char ope1,char ope2);//操作符运算优先级⽐较28double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag);//⽤栈计算表达式结果29double Four_arithm(double x,double y,char oper);//四则运算3031int main()32 {33int select;34while(1)35 {36 Display();37 printf("请输⼊欲执⾏功能对应的数字:");38 scanf("%d",&select);39 printf("\n");40switch(select)41 {42case1: Evalua(); break;43case2: Instru(); break;44case0: return0;45default : printf("⽆该数字对应的功能,请重新输⼊\n");46 system("pause");47 }48 }49return0;50 }5152int Check(char Exp_arry[])53 {//检查是否有⾮法字符,返回1表⽰不合法,0表⽰合法54int Explength=strlen(Exp_arry),i;55for(i=0;i<Explength;i++)56 {57if(!Isoper(Exp_arry[i]) && Exp_arry[i] != '.' && !isdigit(Exp_arry[i]))58return1;59if(isdigit(Exp_arry[i]))60 {61int Dig_number=0,Cur_positoin=i+1;62while(isdigit(Exp_arry[Cur_positoin]) || Exp_arry[Cur_positoin]=='.')63 {64 Dig_number++;65 Cur_positoin++;66 }67if(Dig_number >= 16)//最多能够计算15位有效数字68return1;69 }70 }71return0;72 }7374void Evalua()75 {//先调⽤Conver函数将字符串操作单元化,再调⽤Calculate函数计算结果并输出76char Exp_arry[Expmax_length];77int flag=0;//假设刚开始不合法,1表达式合法,0不合法78struct Ope_unit Opeunit_arry[Expmax_length];7980 getchar();//吃掉⼀个换⾏符81 printf("请输⼊四则运算表达式,以=结尾:\n");82 gets(Exp_arry);83 flag=Check(Exp_arry);84if(flag)85 printf("该表达式不合法!\n");86else87 {88int Opeunit_count = Conver(Opeunit_arry,Exp_arry);89double ans = Calculate(Opeunit_arry,Opeunit_count,flag);90if(flag)91 {92 printf("计算结果为:\n");93 printf("%s%lf\n",Exp_arry,ans);94 }95else96 printf("该表达式不合法!\n");97 }98 system("pause");99 }100101int Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[])102 {//将字符串操作单元化103int Explength=strlen(Exp_arry);104int i,Opeunit_count=0;105for(i=0;i<Explength;i++)106 {107if(Isoper(Exp_arry[i]))//是操作符108 {109 Opeunit_arry[Opeunit_count].flag=0;110 Opeunit_arry[Opeunit_count++].oper=Exp_arry[i];111 }112else//是操作数113 {114 Opeunit_arry[Opeunit_count].flag=1;115char temp[Expmax_length];116int k=0;117for(; isdigit(Exp_arry[i]) || Exp_arry[i]=='.' ;i++)118 {119 temp[k++]=Exp_arry[i];120 }121 i--;122 temp[k]='\0';123 Opeunit_arry[Opeunit_count].real=atof(temp);//将字符转化为浮点数124125//负数126if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0127 && Opeunit_arry[Opeunit_count-1].oper=='-')128 {129 Opeunit_arry[Opeunit_count-1].flag = -1;130 Opeunit_arry[Opeunit_count].real *= -1;131 }// -9132if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0133 && Opeunit_arry[Opeunit_count-1].oper=='-' && Opeunit_arry[Opeunit_count-2].flag==0 134 && Opeunit_arry[Opeunit_count-2].oper !=')')135 {136 Opeunit_arry[Opeunit_count-1].flag = -1;137 Opeunit_arry[Opeunit_count].real *= -1;138 }// )-9139140//正数141if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0142 && Opeunit_arry[Opeunit_count-1].oper=='+')143 {144 Opeunit_arry[Opeunit_count-1].flag = -1;145 }// +9146if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0147 && Opeunit_arry[Opeunit_count-1].oper=='+' && Opeunit_arry[Opeunit_count-2].flag==0148 && Opeunit_arry[Opeunit_count-2].oper !=')')149 {150 Opeunit_arry[Opeunit_count-1].flag = -1;151 }// )+9152 Opeunit_count++;153 }154 }155/*for(i=0;i<Opeunit_count;i++)156 {//查看各操作单元是否正确,1是操作数,0是操作符157 if(Opeunit_arry[i].flag == 1)158 printf("该单元是操作数为:%lf\n",Opeunit_arry[i].real);159 else if(Opeunit_arry[i].flag == 0)160 printf("该单元是操作符为:%c\n",Opeunit_arry[i].oper);161 else162 printf("该单元是负号符为:%c\n",Opeunit_arry[i].oper);163 }*/164return Opeunit_count;165 }166167double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag)168 {//根据运算规则,利⽤栈进⾏计算169int i,dS_pointer=0,oS_pointer=0;//dS_pointer为操作数栈顶指⽰器,oS_pointer为操作符栈顶指⽰器170double Dig_stack[Expmax_length];//操作数栈(顺序存储结构)171char Ope_stack[Expmax_length];//操作符栈172173for(i=0;i<Opeunit_count-1;i++)174 {175if( Opeunit_arry[i].flag != -1 )176 {177if(Opeunit_arry[i].flag)//是操作数178 {179 Dig_stack[dS_pointer++]=Opeunit_arry[i].real;//⼊操作数栈180//printf("%lf\n",Digit[dS_pointer-1]);181 }182else//是操作符 + - * / ( )183 {184//操作符栈为空或者左括号⼊栈185if(oS_pointer==0 || Opeunit_arry[i].oper=='(')186 {187 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;188//printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);189 }190else191 {192if(Opeunit_arry[i].oper==')')//是右括号将运算符⼀直出栈,直到遇见左括号193 {194 oS_pointer--;//指向栈顶195 dS_pointer--;//指向栈顶196while(Ope_stack[oS_pointer] != '(' && oS_pointer != 0)197 {198 Dig_stack[dS_pointer-1] = Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 199 Ope_stack[oS_pointer--]);//oS_pointer--为操作符出栈200201 dS_pointer--;//前⼀个操作数出栈202//printf("操作数栈顶元素等于%lf\n",Digit[dS_pointer]);203 }204 oS_pointer--;//左括号出栈205206 oS_pointer++;//恢复指向栈顶之上207 dS_pointer++;208 }209else if(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer-1]))//和栈顶元素⽐较210 {211 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;212//printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);213 }214else//运算符出栈,再将该操作符⼊栈215 {216 oS_pointer--;//指向栈顶217 dS_pointer--;//指向栈顶218while(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer])==0 && oS_pointer != -1) 219 {//当前操作符⽐栈顶操作符优先级⾼220 Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 221 Ope_stack[oS_pointer--]);222 dS_pointer--;223//printf("操作数栈顶元素等于%lf\n",Digit[dS_pointer]);224 }225 oS_pointer++;//恢复指向栈顶之上226 dS_pointer++;227 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;228 }229 }230 }231 }232 }233/*for(i=0;i<oS_pointer;i++)234 printf("操作符栈%oS_pointer\Ope_u_count",Operator[i]);235 for(i=0;i<dS_pointer;i++)236 printf("操作数栈%lf\n",Digit[i]);*/237 oS_pointer--;//指向栈顶元素238 dS_pointer--;//指向栈顶元素239while(oS_pointer != -1)240 {241 Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 242 Ope_stack[oS_pointer--]);//oS_pointer--为操作符出栈243 dS_pointer--;//前⼀个操作数出栈244//printf("操作数栈顶元素为%lf\Ope_u_count",Digit[dS_pointer]);245 }246//printf("%dS_pointer,%dS_pointer\n",oS_pointer,dS_pointer);247if(oS_pointer==-1 && dS_pointer==0)248 flag=1;//为1表⽰表达式合法249return Dig_stack[0];250 }251252int Ope_Compar(char ope1,char ope2)253 {//操作符运算优先级⽐较254char list[]={"(+-*/"};255int map[5][5]={//先⾏后列,⾏⽐列的运算级优先级低为0,⾼为1256// ( + - * /257/* ( */1,0,0,0,0,258/* + */1,0,0,0,0,259/* - */1,0,0,0,0,260/* * */1,1,1,0,0,261/* / */1,1,1,0,0 };262int i,j;263for(i=0;i<5;i++)264if(ope1==list[i]) break;265for(j=0;j<5;j++)266if(ope2==list[j]) break;267return map[i][j];268 }269270double Four_arithm(double x,double y,char oper)271 {//四则运算272switch(oper)//保证不含其它运算符273 {274case'+': return x+y;275case'-': return x-y;276case'*': return x*y;277case'/': return x/y;//y不能为0278default : return0;279 }280 }281282int Isoper(char ch)283 {//判断合法字符 + - * / ( ) =284if(ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch=='(' || ch==')' || ch=='=')285return1;286return0;287 }288289void Display()290 {//打印菜单291 system("cls");292 printf("/******************************************************************************/\n");293 printf("\t\t 欢迎使⽤本四则运算表达式求值系统\n");294 printf("\n\t说明:建议请您先阅读使⽤说明,再输⼊相应的数字进⾏操作,谢谢配合!\n"); 295 printf("\n\t\t1 四则运算表达式求值\n");296 printf("\n\t\t2 使⽤说明\n");297 printf("\n\t\t0 退出\n");298 printf("/******************************************************************************/\n");299 }300301void Instru()302 {//打印使⽤说明303 FILE *fp;304char ch;305if( ( fp=fopen("使⽤说明.txt","r") ) == NULL)306 {307 printf("⽂件打开失败!\n");308 exit(0);309 }310for(; (ch = fgetc(fp)) != EOF; )311 putchar(ch);312 fclose(fp);313 printf("\n");314 system("pause");315 }。

C语言下表达式的自动计算(两种方式)(报告+源代码)

一、设计思想第一种算法:将中缀表达式转为后缀表达式,然后通过后缀表达式计算出算术表达式的结果。

核心思想:第一步:中缀变后缀。

首先,我们做出一个统一的Node结构体,结构体内部包含四个属性,分别是操作符的字符‘op’,char类型;操作符的优先级‘level’,int 类型;数字的浮点数数值‘od’,float类型;Node的标识符,int类型。

然后,定义一个Node结构体类型的数组*listNode,这里的*listNode用的是全局变量,为了方便在得到后缀表达式后,不需再传递给计算的方法。

定义一个存放操作符的栈,遍历用户输入的算术表达式(不考虑错误情况),在遍历的过程中如果遇到数字,直接将数字存放在*listNode里面;如果遇到了操作符,则判断操作符栈目前是不是为空,如果为空,直接将遇到的操作符放入操作符栈中,如果操作符栈不为空,那么观察操作符栈中栈顶的操作符,然后再次判断当前遇到的操作符的优先级是不是比栈顶的操作符的优先级高,如果是,那么将当前的操作符入操作符栈;如果不是,那么将操作符栈的栈顶操作符取出,追加到*listNode中,然后继续观察栈顶操作符,直到当前的操作符的优先级比栈顶操作符的优先级高或者操作符栈为空时,将当前操作符入操作符栈。

如果遇到了左括号,那么定义其优先级为最低,然后直接将左括号入操作符栈。

如果遇到了右括号,那么开始从操作符栈中取出操作符追加到*listNode中,直到遇到了与之对应的左括号,然后将左括号和右括号一起销毁。

当遍历完成了算术表达式之后,这时判断操作符栈是否为空,如果不为空,那么从操作符栈中依次取出栈顶操作符追加到*listNode中,直到操作符栈为空,那么就代表我们将中缀表达式转变成为了后缀表达式。

第二步:通过得到的后缀表达式,计算算术表达式。

首先,定义一个数字栈用来存放数值。

然后,遍历*listNode中的每一个Node,如果Node是一个数字,那么就将数字入数字栈,如果Node是一个操作符,那么就从数字栈中依次取出栈顶的两个数字,然后根据操作符计算这两个数字,将得到的结果再次入数字栈,直到遍历*listNode完成,最终数字栈中会只剩下一个Node,那就是我们计算出算术表达式的结果,将结果返回给main 函数用来输出。

c两种方法实现表达式的计算 (1)

数据结构(双语)——项目文档报告用两种方式实现表达式自动计算专业:网络工程班级:网络1班指导教师:吴亚峰姓名:王嘉宇学号:201214620111目录一、设计思想 (01)二、算法流程图 (01)三、源代码 (04)四、运行结果 (12)五、遇到的问题及解决 (13)六、心得体会 (14)一、设计思想(1)先将中缀表达式转化为后缀表达式,再通过计算后缀表达式求表达式的值。

第一遍扫描中缀表达式,需要一个运算符栈和一个数组。

运算符栈用来存放运算符,数组用来存放转换成的后缀表达式。

首先将中缀表达式挨个扫描。

如果是数字,则直接放在后缀表达式数组中,依次存放。

如果扫描到的是运算符,则按照以下规则存放:栈空时,任何运算符可直接入栈。

栈不空是,如果栈中运算符的优先级高于或等于将要放入栈中的运算符的优先级,则将栈中运算符出栈,放入后缀表达式数组中,直到栈中运算符优先级低于将要放入栈中的运算符的优先级,此时将此运算符放入运算符栈中。

如果遇到左括号,则直接将左括号入栈,左括号入栈后优先级最低,其他运算符可直接放入。

如果遇到右括号,则将运算符栈中的运算符依次取出放到后缀表达式数组中,直到遇到左括号为止,此时将左括号从栈顶删除。

按此方法,直到后缀表达式转换成功。

第二遍扫描后缀表达式,此时需要一个数栈。

扫描时如果遇到数字,则直接放到数栈中。

如果遇到运算符,则将数栈中两个数取出,先取出的放在运算符后面,后取出的放在运算符前面,进行运算符运算。

将运算的结果放入栈中。

之后接着扫描后缀表达式。

另外因为运算数的位数不一定而且还有小数点,所以在扫到一个数时要判断这个数的位数,将这个完整的运算数字符串整个取出,这需要用到一个辅助索引。

当栈中只有一个数字时,这个数字就是我们要求的表达式的值。

(2)直接计算表达式的值。

这种方法需要两个栈,一个运算符栈,一个数栈。

只需扫描一遍中缀表达式,边运算边入栈。

当扫描到的为数字是,将其放入数栈中,然后扫描下一个字符。

算术表达式计算的实现(C语言)

分:
1 )表达式 中缀转化为后缀; 2 )后缀表达式的计算 。 ( 1 ) 中缀 转 化 为后 缀 在本 程序 中,建立 了一个操作符栈o p 和一个字符数组e x p 。o p 栈存放表达式中的 操作符 ( 运算符号 ),e x p 数组中存放转换 以后 的后 缀 表 达 式 。具 体 运 行 过 程 如 下 : 首先 ,输 入一个算术表达式 ( 中缀 ),将 其存入事 先定义的s t r 数 组 中 。对 s t r 数 组 中的每个 字符依次扫描 ,如果 是数字或者 是小数点,则直接存入e x p 数组中,每存入 个数字或小数点,在后面加一个# 作为分 隔符 。 如果是操作 符,并且栈为 空则 直接入 栈 ;如果栈不为空格 ,则与栈顶的操作符 进 行优先级 比较 ,若 比栈 顶的优先级高 , 则入 栈;反之 ,则 出栈将 其操作符存放到 e x p 数组 中,知道栈顶 元素 的优先级等级低 于扫 描的操作符 ,则此操 作符入栈 ;如果 是左括号,则直接入栈 ;如果是右括号 , 则出栈存入 ̄ 1 ] e x p 数组,直 到遇到左括号。 直扫描 ̄ J l s t r 的结束符号\ O 。结束后看0 p 栈是否为 空,若不为空则继续出栈存入e x p 数组中,直到栈为空。到此在e x p 数组最后 在加 结束符号\ 0 。 ( 2 ) 后缀表达 式的计算 在本程序 运行过程 中,先建立一个 数 值栈0 d ,用来存放 数值 。首先,对e x p 数组
I 一 学 熏 …………………………一 算 术 表 达 式 计 算 的实 现 ( c语 言 )
西安 电子科技 大学 钱学林
【 摘要 】算术表达 武实现程序是计 算数学表达武方法的一种。本程序 由( : 语言编写 ,主要涉及一 维结构体 、宏定义、函数、 中缀、后缀 等基本 知识。本程序 由七个 函数模 块来实现功能 ,分别为 负号处理、 中缀转后缀、优先级 比较、乘方的计算、算术运算、后缀表达 式计算六个子 函数和 一个 主函数 ,分别使 用到了结构、s w i t h q .  ̄ 、数组、 后缀 中缀表示等知识。 【 关键 词】后缀 ;中缀 ;函数;结构体
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

#include <stdio.h>#include <stdlib.h>#define STACK_SIZE 100typedef struct /* 定义一个运算符栈*/{char * base; /*指向栈底的指针*/char * top; /*指向栈顶的指针*/}OPTR_Stack;typedef struct /* 定义一个操作符栈*/{float * base;float * top;}OPND_Stack;void OptrInIt(OPTR_Stack *s) /* 初始化运算符栈*/{s->base=(char*)malloc(STACK_SIZE*sizeof(char));/*分配内存*/ if(s->base==NULL) exit(0); /* 判断栈是否为空*/s->top=s->base; /* 初始化栈*/}int OptrEmpty(OPTR_Stack s) /* 定义栈空事件*/{if(s.top==s.base) /*判断栈空*/return 1; /* 栈空返回1,否则为0 */ elsereturn 0;}void OptrPush(OPTR_Stack *s,char elem) /* 入栈操作符*/ {if (s->top-s->base==STACK_SIZE) /* 判断栈满*/{printf("OPTR_Stack is full!\n"); /*栈满则打印*/getch(); /*停止*/exit(0);}else*(s->top++)=elem; /*栈未满则elem入栈*/ }char OptrPop(OPTR_Stack *s) /* 出栈*/{char elem; /*定义字符变量*/if(OptrEmpty(*s)) /*判断栈是否为空*/{printf("Stack is empty\n"); /*栈空打印*/getch(); /*停止*/exit(0);}else{elem=*--s->top; /*出栈值传给elem*/return elem;}}char OptrGetTop(OPTR_Stack s) /* 获取栈顶元素*/{char elem; /*定义字符变量*/if(!OptrEmpty(s)) /*判断栈s是否为空*/{elem=*(s.top-1); /*将栈顶元素值传给elem*/return elem;}}void OpndInit(OPND_Stack *s) /* 初始化数栈*/{s->base=(float *)malloc(STACK_SIZE*sizeof(float));/*分配内存*/ if(s->base==NULL) exit(0); /* 判断栈是否为空*/s->top=s->base; /* 初始化栈*/}int OpndEmpty(OPND_Stack s) /* 判断数栈是否为空*/{if(s.top==s.base)return 1; /*栈为空则返回1*/elsereturn 0; /*栈不为空则返回0*/}void OpndPush(OPND_Stack *s,float elem) /* 入栈*/{if (s->top-s->base==STACK_SIZE) /* 判断栈满*/{printf("OPND_Stack is full!\n"); /*栈满则打印*/getch(); /*停止*/exit(0);}else*s->top++=elem; /*栈未满则elem入栈*/}float OpndPop(OPND_Stack *s) /* 出栈*/{float elem; /*定义字符变量*/if(OpndEmpty(*s)) /*判断栈s是否为空*/{printf("OPND_Stack is empty\n"); /*栈空则打印*/getch(); /*停止*/exit(0);}else{elem=*--s->top; /*栈非空出栈*/return elem;}}float OpndGetTop(OPND_Stack s) /* 获取栈顶元素*/{float elem; /*定义字符变量*/if(!OpndEmpty(s)) /*判断栈s是否为空*/{elem=*(s.top-1); /* 将栈顶值传给elem*/return elem; /*返回值*/}}int isoper(char c) /* 判断是否为运算符*/{if(c=='+'||c=='-'||c=='*'||c=='/'||c=='%')return 1; /*如果c是'+''-''/''*'中的一种则返回1*/ elsereturn 0; /*否则返回0*/}int priority(char c) /* 判断优先级*/{int p; /*定义一个整型数*/switch(c){case '+':case '-': p=1;break; /* +-的优先级为1*/case '*':case '%':case '/': p=2;break; /* '*''%''/'的优先级为2*/case '(': p=0;break; /* (的优先级为0*/}return(p); /*返回值*/}float calculate(float s1,float s2,char oper) /* 计算表达式*/{float y; /*定义一个浮点型*/switch(oper){case '+': y=s2+s1;break;case '-': y=s2-s1;break;case '*': y=s2*s1;break;case '%': y=(int)((int)s2%(int)s1); break;case '/': /*情形为'/'时*/if(s1==0) /*当除数为0时*/{printf("\nDevided by zero!"); /*打印除数为0*/getch(); /*停止*/exit(0);}y=s2/s1;break; /*除数不为0则定义y值为两数商*/ }return(y); /*返回值*/}float StrToFloat(char *s,int *j) /* 将字符串转化成数字*/{int i,k; /*定义两个整型变量*/char n[100]; /*定义一个数组*/float f; /*定义一个浮点型*/i=*j;for(k=0;s[i]>='0' && s[i]<='9' || s[i]=='.';i++,k++) /*当数组里为0~9的数值或是小数点*/ {n[k]=s[i]; /*将字符存入数组*/}n[k]='\0'; /*存入一个数值后数值间加空格*/*j=i;f=atof(n); /*将字符数组转换成浮点型数据*/return(f); /*返回值*/}float compute(char *exp1){char oper;int i;float OPND1,OPND2,result,f;OPTR_Stack OPTR; /* 运算符栈OPTR*/OPND_Stack OPND; /*操作数栈OPND */OptrInIt(&OPTR); /*初始化符号栈*/OpndInit(&OPND); /*初始化操作数栈*/printf("\n你输入的表达式是:");puts(exp1); /*输出输入的表达式*/for(i=0;exp1[i]!='\0' && exp1[i]!='\n';i++){if(!isoper(exp1[i]) && exp1[i]>='0' && exp1[i]<='9' || exp1[i]=='.') /* 将字符型的操作数转化为数字,存入数栈中*/{f=StrToFloat(exp1,&i); /*将数组exp1中的字符型操作数转换为浮点型的数*/OpndPush(&OPND,f); /*将转换后的数存入数栈中*/}if(isoper(exp1[i])) /* 为运算符时*/{if(!OptrEmpty(OPTR)) /*当符号栈不为空时*/{while(!OptrEmpty(OPTR) && priority(exp1[i])<=priority(OptrGetTop(OPTR)))/* 比较优先级,栈顶运算符优先级高时,运算符出栈*/{oper=OptrPop(&OPTR); /*出栈将值传给oper*/OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/result=calculate(OPND1,OPND2,oper); /*计算*/OpndPush(&OPND,result); /*计算结果入栈*/}OptrPush(&OPTR,exp1[i]); /*栈顶运算符优先级低时,运算符入栈*/}elseOptrPush(&OPTR,exp1[i]); /*符号栈为空时,运算符入栈*/ }else if(exp1[i]=='(') OptrPush(&OPTR,exp1[i]); /*'('入栈*/else if(exp1[i]==')'){while(OptrGetTop(OPTR)!='(' && !OptrEmpty(OPTR))/*运算符出栈,直到遇到')'或者栈空*/{oper=OptrPop(&OPTR); /*出栈将值传给oper*/OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/result=calculate(OPND1,OPND2,oper); /*计算*/OpndPush(&OPND,result); /*计算结果入栈*/}OptrPop(&OPTR); /*将栈内的'('丢掉*/}}while(!OptrEmpty(OPTR)) /*符号栈不为空*/{oper=OptrPop(&OPTR); /*出栈将值传给oper*/OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/result=calculate(OPND1,OPND2,oper); /*计算*/OpndPush(&OPND,result); /*计算结果入栈*/}return result;}void main(){float result;char exp1[100]; /*表达式*/printf("请输入要计算的表达式: ");gets(exp1); /*输入值放入数组exp1中*/result = compute(exp1);printf("\n结果是: %.2f",result); /*打印结果*/getch();}。

相关文档
最新文档