C语言表达式求值

合集下载

c语言表达式题库

c语言表达式题库

c语言表达式题库(总1页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--C语言程序设计表达式一、表达式求值1.表达式:!(4<=6)&&(3<=7) 的值为_______ 02.表达式:x=!(2<5==5) 的值为【1】 13.如果有变量定义:int i=1,j=8,a;则表达式:a=i+(j%4!=0) 的值为_【1】 14.表达式:x=(7+6)%4/2 的值为【1】 05.如果有变量定义:int x,则表达式:x=-3*4%-6/50 的值为【1】 06.如果有变量定义:int x ,则表达式:x=3+7%5-6 的值为【1】 -17.如果有变量定义:int x,则表达式:x=-3+4/5-6 的值为【1】 -98.如果有变量定义:int x=3,y=4,z=4则表达式:z>=y&&y>=x 的值为_____ 19.如果有变量定义:int x=3,y=4,z=4则表达式:(z>=y>=x)1:0 的值为____ 0 10.如果有变量定义:int x=0,y=0,z=0则表达式:k=++x&&++y||++z 的值为_____ 111. 如果有变量定义:int x=0,y=0,z=0则表达式:k=++x||++y&&++z 的值为______ 112. 如果有变量定义:int x=40,y=4,z=4则表达式:x=x==(y-z) 的值为____ 013.如果有变量定义:int a=15,则表达式:a=a<<1 的值为【1】 3014.如果有变量定义:int y;char x='a';则表达式:y='a'+1 的值为【1】 9815.如果有变量定义float x=,y=则表达式:x<y:的值为【1】16.如果有变量定义:int a=1,b=2,c=3,d=5则表达式:a>b a : c>d c : d 的值为【1】 517.如果有变量定义:int a=1,b=3,m 则表达式:m=a>b a : b+1 的值为【1】 418.如果有变量定义:int a=1,b=2则表达式:(!a)||(a>b) 的值为_______ 019. 如果有变量定义:int a=1,b=2,c=1,x=4,y=5则表达式:!a&&b||x>y&&c 的值为______ 020如果有变量定义:int a=12,n=5则表达式:a%=(n%=2) 的值为_______ 021如果有变量定义:int a=2, b=3;float x=, y=则表达式:(float)(a+b)/2+(int)x%(int)y 的值为【1】22如果有变量定义:int x=, y=则表达式:z=(int)x%(int)y 的值为【1】 1 23如果有变量定义:int x=,a=7,y=则表达式:k=a%3*(x+y)/2 的值为【1】 3 24如果有变量定义:int a=5则表达式:a*=1+3 的值为【1】 2025如果有变量定义:int a,b则表达式:b=(a=3*4, a*4),a+5 的值为【1】 17 26如果有变量定义:int a,b 则表达式:x=a=3,5*a 的值为【1】 1527如果有变量定义:int a=120 则表达式:a%=(5%2) 的值为【1】 028如果有变量定义:int a=10则表达式:a+=a-=a*=a 的值为【1】 029 如果有变量定义:int a=10则表达式:a+=a-=a*a 的值为【1】 -180 30 如果有变量定义:int i=3则表达式:j=i++ 的值为【1】 331如果有变量定义:int i=3则表达式:j=++i 的值为【1】 432表达式5&7的值为【1】 ,5│7的值为【2】 . 5 72。

c语言算术表达式求值

c语言算术表达式求值

c语言算术表达式求值C语言是一种广泛应用的编程语言,其强大的算术表达式求值功能使其在科学计算、数据处理、游戏开发等领域有着重要的应用。

本文将介绍C语言中算术表达式求值的相关知识,包括运算符、运算符优先级、表达式求值的顺序等内容。

我们需要了解C语言中常用的算术运算符。

C语言支持的算术运算符包括加法(+)、减法(-)、乘法(*)、除法(/)和求余(%)等。

这些运算符用于对数值进行基本的加减乘除运算。

在C语言中,运算符的优先级决定了表达式求值的顺序。

常见的运算符优先级从高到低依次为:1. 括号(()):括号中的表达式具有最高的优先级,可以改变默认的运算次序。

2. 一元运算符:包括正号(+)和负号(-),用于表示正负数。

3. 乘法、除法和求余:乘法(*)、除法(/)和求余(%)的优先级相同,从左到右依次计算。

4. 加法和减法:加法(+)和减法(-)的优先级相同,从左到右依次计算。

在使用C语言进行算术表达式求值时,我们需要遵循这些运算符的优先级规则,以保证表达式的正确求值。

如果表达式中包含多个运算符,我们需要根据优先级确定运算的顺序,可以使用括号来改变默认的运算次序。

下面我们将通过几个例子来说明C语言中算术表达式求值的过程。

例1:求解一个简单的算术表达式假设我们需要计算表达式 3 + 4 * 2,根据运算符优先级规则,先计算乘法,再计算加法。

具体的求解过程如下:1. 计算4 * 2,得到8。

2. 计算3 + 8,得到11。

所以,表达式3 + 4 * 2的值为11。

例2:使用括号改变运算次序假设我们需要计算表达式(3 + 4) * 2,根据运算符优先级规则,先计算括号内的加法,再计算乘法。

具体的求解过程如下:1. 计算3 + 4,得到7。

2. 计算7 * 2,得到14。

所以,表达式(3 + 4) * 2的值为14。

通过以上两个例子,我们可以看到,C语言中的算术表达式求值是按照运算符优先级和运算次序进行的,遵循从左到右的计算规则。

c语言算术表达式求值

c语言算术表达式求值

c语言算术表达式求值【实用版】目录1.引言2.C 语言算术表达式的基本概念3.C 语言算术表达式的求值方法4.实际应用示例5.总结正文【引言】在 C 语言编程中,算术表达式是用来进行数值计算的重要工具。

本篇文章将为大家介绍 C 语言算术表达式的求值方法。

【C 语言算术表达式的基本概念】C 语言中的算术表达式主要包括以下几种:1.一元运算符:例如+、-、*、/等,用于对一个数值进行操作。

2.二元运算符:例如+、-、*、/等,用于对两个数值进行操作。

3.关系运算符:例如<、>、<=、>=、==、!=等,用于比较两个数值的大小或相等性。

4.逻辑运算符:例如&&、||、! 等,用于进行逻辑判断。

【C 语言算术表达式的求值方法】C 语言中,算术表达式的求值主要遵循以下规则:1.先进行括号内的运算,再进行括号外的运算。

2.先进行乘除法运算,再进行加减法运算。

3.关系运算符和逻辑运算符的优先级较低,从左到右依次进行运算。

【实际应用示例】下面我们通过一个实际的 C 语言程序,来演示算术表达式的求值过程。

```c#include <stdio.h>int main() {int a = 10, b = 5;int result;result = a + b * (a - b) / (a * b);printf("The result is: %d", result);return 0;}```在这个程序中,我们定义了两个整数变量 a 和 b,并通过算术表达式计算 result 的值。

根据我们之前提到的算术表达式求值规则,我们可以将这个表达式分解为以下几个步骤:1.计算括号内的值:a - b = 10 - 5 = 52.计算乘法运算:b * (a - b) = 5 * 5 = 253.计算除法运算:(a * b) / (a * b) = 14.计算加法运算:a + 25 = 10 + 25 = 355.输出结果:printf("The result is: %d", result); 输出 35【总结】通过本篇文章的介绍,相信大家已经对 C 语言算术表达式的求值方法有了更加深入的了解。

C语言(填空)2

C语言(填空)2

一、表达式求值┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅〖第1题〗如果有变量定义:char ch='B';则程序段ch=(ch>='A'&&ch<='Z')?(ch+32):ch;printf("%c",ch)的输出结果为【1】〖第2题〗如果有变量定义:int a=2则表达式:a+=a-=a*a 的值为【1】〖第3题〗表达式:x=!3<(5==5)的值为【1】〖第4题〗如果有变量定义:int x=1,y=1,z=1则表达式:k=++x&&++y||++z 的值为_____〖第5题〗如果有变量定义:int x=5,则表达式:x>>1的值为【1】〖第6题〗如果有变量定义:int x=3,y=4,z=5;则表达式:x+=y-=z*=x的值为【1】〖第7题〗如果有变量定义:int x=3.5,a=7,y=6.7则表达式:k=a%3*(x+y)/2 的值为【1】〖第8题〗如果有变量定float x=5.0,y=4.0则表达式:x<y?1.0:1.5的值为【1】〖第9题〗如果有变量定义:int a=5,b=4则表达式:a>b?3:1.5的值为【1】〖第10题〗如果有变量定义:int a=15,则表达式:a=a<<2 的值为【1】〖第11题〗如果有变量定义:int a=4, b=3;float x=4.5, y=2.5则表达式:(float)(a+b)/2+(int)x%(int)y 的值为【1】〖第12题〗如果有变量定义:int i=2则表达式:j=i++的值为【1】〖第13题〗如果有变量定义:int a=1,b=4;则表达式:a>b? a : b+2 的值为【1】〖第14题〗如果有变量定义:int a=90则表达式:a+=a-=a*=a 的值为【1】〖第15题〗如果有变量定义:int a=1,b=2,c=1,x=4,y=5则表达式:!a&&b||x>y&&c 的值为【1】〖第16题〗如果有变量定义:int x=4.6,y=2.5则表达式:z=(int)x%(int)y 的值为【1】〖第17题〗如果有变量定义:int x,则表达式:x=-3*5%(14/5) 的值为【1】〖第18题〗如果有变量定义:float x=4,则表达式:sizeof(x)的值为【1】〖第19题〗如果有变量定义:int a=11则表达式:a%=(5%2) 的值为【1】〖第20题〗如果有变量定义:int a=5则表达式:a*=3+4 的值为【1】〖第21题〗表达式:x=(17+5)%4/2 的值为【1】〖第22题〗如果有变量定义:int i=1,j=9,a;则表达式:a=i+(j%4!=0) 的值为_【1】〖第23题〗如果有变量定义:int y;char x='b';则表达式:y=x+1 的值为【1】〖第24题〗如果有变量定义:double x=0.3,y=0.5,z=0.8;则表达式:x>y>z的值为【1】〖第25题〗如果有变量定义:int x=0,y=0,z=0则表达式:k=++x||++y&&++z 的值为______〖第26题〗如果有变量定义:int a=1,b=2,c=3,d=6则表达式:a>b?a:c>d?c:d 的值为【1】〖第27题〗如果有变量定义:int x=30,y=3,z=4则表达式:x=x=(y+z) 的值为____〖第28题〗如果有变量定义:int a=8,n=5则表达式:a/=(n%=2) 的值为【1】〖第29题〗如果有变量定义:int a,b则表达式:b=(a=3*2, a*4),a+5 的值为【1】〖第30题〗如果有变量定义:int x=0x12;则表达式:printf("%d",x++);的为【1】〖第31题〗如果有变量定义:int x=4,y=4,z=3则表达式:z>=y&&y>=x 的值为_____〖第32题〗如果有变量定义:int x=3,y=4,z=5则表达式:(z>=y>=x)?1:0 的值为____〖第33题〗如果有变量定义:int a=3,b=4则表达式:(!a)||(a>b) 的值为【1】〖第34题〗如果有变量定义:int a,b 则表达式:x=a=4,5*a的值为【1】〖第35题〗如果有变量定义:int x,则表达式:x=-3+4/3-7 的值为【1】〖第36题〗如果有变量定义:int x ,则表达式:x=3+7%5-7 的值为【1】〖第37题〗如果有变量定义:int i=2则表达式:j=++i的值为【1】〖第38题〗表达式:!(7<=6)&&(5<=6) 的值为【1】.二、填空1."字符常量'a'在内存中应占【1】字节,字符串""a""应占【2】字节." 1 22."在16位PC机环境下,int类型数据应占【1】字节,double类型数据应占【2】字节." 2 83"在16位PC机环境下,int类型数据的取值范围是–32768到【1】 327674 unsigned int类型数据的取值范围是0到【1】 ." 655355"若采用十进制数的表示方法,则0110是【1】 ." 726"若有说明char s1='\x77';,则s1中包含【1】字符" 1 中7"设x为float型变量,y为float型变量,a为int型变量,b为long型变量,c为char型变量,则表达式x+y*a/x+b/y+c 的结果为【1】类型." double8 "定义如下变量:int x=2.5,y=4.7; int a=7;表达式 x+a%3*(int)(x+y)%2/4的值为【1】 ." 29 "设a,c,x,y,z均为int型变量,请在下面对应的位置上写出各表达式的结果.① a=(c=5,c+6,c/2) 【1】② x=(y=(z=6)+2)/5 【2】" 2 110"下列程序的输出结果为__________.main(){ int unsigned x1; int b=-1;x1=b; printf("%u",x1);}" 6553511 "下列程序的输出结果为【1】.main(){ int a=5;printf("%d,", (3+5,6+9));a=(3*5,a+4); printf("a=%d\n",a);}15,a=912 下列程序的输出结果为【1】.main(){ int x, y, z;x=24; y=025; z=0x24;printf("%d,%d,%d", x, y, z);} 24,21,3613 "下列程序的运行结果为【1】.main(){ char c1='a',c2='b',c3='c';printf("a%cb%cc%c"",c1,c2,c3);} aabbcc14 "设有变量定义:int j; float y;,输入字符流行:12345a72当执行C语句scanf("%2d%f",&j,&y);和printf("%d,%.1f",j,y);后,输出是【1】." 12,345.015 "以下程序的输出结果是【1】.void main(){ unsigned int a=65535;int b;printf("%d\n",b=a);} -116"若有定义:int a=10,b=9,c=8;接着顺序执行下列语句后,变量c的值是【1】_.c=(a-=(b-5));c=(a%11)+(b=2);817 "以下程序执行后的输出结果是【1】.main(){ int a=5,b,c;a*=3+2;printf("%d",a);a*=b=c=5;printf("%d",a);} 2512518 "完善程序:判断输入的一个整数是否能被3或7整除,若能输出YES,若不能输出NO.main(){ int k;printf(""Enter a int number:""); scanf(""%d"",&k);if(【1】) printf(""YES\n"");else printf(""NO\n"");}k%3==0 || k%7==019"设i为int型变量,则下面程序段的输出结果是【1】.for(i=1; i<=2; i++) printf("OK");OKOK20 "在C语言的文件系统中,最重要的概念是"文件指针",文件指针的类型只能是_______ 类型. FILE21 "C语言调用【1】函数打开文件,调用【2】函数关闭文件.fopen fclose。

基于栈的后缀算术表达式求值c语言

基于栈的后缀算术表达式求值c语言

基于栈的后缀算术表达式求值c语言1. 引言1.1 概述本文将讨论基于栈的后缀算术表达式求值的实现过程。

后缀算术表达式(也称为逆波兰表达式)是一种无需括号即可进行运算的表达式表示方法,它将操作符置于操作数之后。

相较于传统的中缀表达式,在计算机程序中处理后缀表达式更为高效和简洁。

1.2 文章结构文章分为五个主要部分:引言、栈的概念及原理、后缀算术表达式的定义和转换、基于栈的后缀算术表达式求值算法实现以及结论与总结。

在引言部分,我们将首先介绍本文的概述和目标,对后续内容进行简要说明。

1.3 目的通过本文,我们旨在让读者了解栈数据结构的基本概念和原理,并且掌握如何利用栈来实现对后缀算术表达式进行求值的算法。

同时,我们将介绍后缀算术表达式的定义和转换方法,并给出基于栈实现该计算方式的详细步骤与示例代码。

通过深入研究并学习这些内容,读者可以加深对栈数据结构和后缀算术表达式的理解,并且能够应用所学知识解决实际问题。

本文不仅适用于计算机科学或相关专业的学生,也适合对数据结构和算法感兴趣的读者阅读和学习。

2. 栈的概念及原理2.1 栈的定义栈是一种具有特定限制条件的线性数据结构,它具备“先进后出”(Last-In-First-Out,LIFO)的特性。

栈可以看作是一个容器,其中可以存储各种类型的数据。

与实际生活中的堆栈类似,栈只允许在其末尾进行插入和删除操作。

在栈中,最后加入的元素首先被访问和处理。

这是由于栈内元素之间的相对位置关系决定的。

插入操作称为“压栈”(Push),删除操作称为“弹栈”(Pop),而从栈顶读取元素或获取栈顶元素但不删除它称为“查看”(Peek)。

2.2 栈的基本操作推入元素:将一个元素添加到栈顶。

如果已经存在满员条件,则无法执行此操作。

弹出元素:从栈顶移除一个元素,并返回移除的值。

如果没有任何元素存在,则无法执行此操作。

查看栈顶元素:获取位于栈顶处的元素值,但不对其进行删除。

判断是否为空:检查栈是否为空。

表达式求值c语言程序

表达式求值c语言程序

表达式求值c语言程序#include <stdio.h>#include <stdlib.h>#include <ctype.h>char expression[100];int pos = 0;int num1, num2;char op;int parse_expr() {int i;num1 = parse_term();while (expression[pos] != '\0') {op = expression[pos];pos++;num2 = parse_term();switch (op) {case '+':num1 += num2;break;case '-':num1 -= num2;break;case '*':num1 *= num2;break;case '/':num1 /= num2;break;default:printf("Invalid operator: %c\n", op); exit(1);}}return num1;}int parse_term() {int i, n = 0;while (isdigit(expression[pos])) {n = n * 10 + (expression[pos] - '0'); pos++;}return n;}int main() {printf("Enter an expression: ");fgets(expression, 100, stdin);pos = 0;printf("Result: %d\n", parse_expr());return 0;}该程序使用递归下降解析算法来解析表达式。

在解析表达式时,程序从左到右依次扫描表达式中的每个字符,并使用递归函数来解析每个子表达式和操作数。

数据结构课程设计四则运算表达式求值(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语言表达式求值

C语言表达式求值

表达式求值,输入一个表达式,如1+2*3#,程序可计算出结果为7支持以下符号:+ - * / ( ) ^ .可以计算整数、小数其中^表示次方,2^5表示2的5次方*//*头文件*/#include <>#include <>#include <>#include <>#include <>/*宏定义*/#define INIT_STACK_SIZE 100#define SET_NUM 8#define N 100/*字符优先级表*/unsigned char prior[SET_NUM][SET_NUM] ={/* '+' '-' '*' '/' '(' ')' '#' '^' *//*'+'*/'>', '>', '<', '<', '<', '>', '>', '<',/*'-'*/'>', '>', '<', '<', '<', '>', '>', '<',/*'*'*/'>', '>', '>', '>', '<', '>', '>', '<',/*'/'*/'>', '>', '>', '>', '<', '>', '>', '<',/*'('*/'<', '<', '<', '<', '<', '=', ' ', '<',/*')'*/'>', '>', '>', '>', ' ', '>', '>', '>',/*'#'*/'<', '<', '<', '<', '<', ' ', '=', '<',/*'^'*/'>', '>', '>', '>', '<', '>', '>', '>'};unsigned char priorSet[SET_NUM] = {'+', '-', '*', '/', '(', ')', '#', '^'};/*结构体定义,这是用来存放字符的栈*/typedef struct{char *base;char *top;int stacksize;} SqStackC;/*结构体定义,这是用来存放数字的栈*/typedef struct{double *base;double *top;int stacksize;} SqStackN;void initStackN(SqStackN &);void initStackC(SqStackC &);void pushN(SqStackN &, double);void pushC(SqStackN &, double);void popN(SqStackN &, double &);void popC(SqStackN &, double &);double calculate(double, char, double);int findInSet(char);char compare(char, char);void getSolution();/*主函数*/void main(){getSolution();}/*初始化数字栈*/void initStackN(SqStackN &S){= (double*) malloc(INIT_STACK_SIZE * sizeof(double));= ;= INIT_STACK_SIZE;}/*初始化字符栈*/void initStackC(SqStackC &S){= (char*) malloc(INIT_STACK_SIZE * sizeof(char));= ;= INIT_STACK_SIZE;}/*向数字栈中存放数字*/void pushN(SqStackN &S, double x){if >=return;*++) = x;}/*向字符栈中存放字符*/void pushC(SqStackC &S, char x){if - >=return;*++) = x;}/*从数字栈中取出数字*/void popN(SqStackN &S, double &x){if ==return;x = *;}/*从字符栈中取出字符*/void popC(SqStackC &S, char &x){if ==return;x = *;}/*这个函数返回a operation b的值。

c语言基于二叉树的表达式求值算法

c语言基于二叉树的表达式求值算法

c语言基于二叉树的表达式求值算法C语言中,基于二叉树的表达式求值算法主要包括两部分:中缀表达式转换为后缀表达式和后缀表达式求值。

1.中缀表达式转换为后缀表达式中缀表达式是我们常见的数学表达方式,例如3 + 4 * 2 - 5。

为了方便计算机求值,我们需要将中缀表达式转换为后缀表达式,也叫做逆波兰表达式。

转换的过程使用栈数据结构来实现。

具体算法如下:1.定义一个栈和一个结果字符串,栈用于存储操作符,结果字符串用于保存后缀表达式。

2.从左到右遍历中缀表达式的每一个字符。

3.如果当前字符是数字,直接将其加入结果字符串。

4.如果当前字符是左括号"(",将其入栈。

5.如果当前字符是右括号")",则依次将栈顶的操作符弹出并加入结果字符串,直到遇到左括号为止,同时将左括号从栈中弹出。

6.如果当前字符是操作符,需要将栈中优先级比当前操作符高或者相等的操作符弹出并加入结果字符串,然后将当前操作符入栈。

7.遍历完所有字符后,将栈中剩余的操作符依次弹出并加入结果字符串。

8.最终结果字符串就是后缀表达式。

例如,对于中缀表达式3 + 4 * 2 - 5,转换为后缀表达式为3 4 2 * + 5 -2.后缀表达式求值后缀表达式求值算法使用栈数据结构来实现。

具体算法如下:1.定义一个栈,用于存储操作数。

2.从左到右遍历后缀表达式的每一个字符。

3.如果当前字符是数字,则将其转换为对应的整数并入栈。

4.如果当前字符是操作符,则从栈中弹出两个操作数,先弹出的作为右操作数,后弹出的作为左操作数,根据操作符进行运算,得到结果后入栈。

5.遍历完所有字符后,栈顶的数字即为最终的结果。

例如,对于后缀表达式3 4 2 * + 5 -,求值的过程如下:1.入栈3。

2.入栈4。

3.入栈2。

4.弹出2和4,计算4 * 2 = 8,将8入栈。

5.弹出8和3,计算3 + 8 = 11,将11入栈。

6.入栈5。

7.弹出5和11,计算11 - 5 = 6,得到最终结果。

用栈解决表达式求值问题的c语言代码

用栈解决表达式求值问题的c语言代码

栈是一种常见的数据结构,用于解决许多算法和数据处理问题。

在编程中,栈通常用于处理表达式求值问题。

本篇文章将介绍如何使用栈解决表达式求值问题,并给出对应的C语言代码。

1. 表达式求值问题介绍表达式求值是指计算一个数学表达式的值,通常涉及到四则运算、括号和优先级等概念。

给定一个表达式“3 + 4 * 2”,我们需要得到其计算结果为11。

在编程中,需要将该表达式转换为计算机可识别的形式,并使用算法进行求值。

2. 中缀表达式、前缀表达式和后缀表达式在计算机中常见的表达式有三种形式:中缀表达式、前缀表达式和后缀表达式。

其中,中缀表达式是通常人们在日常生活中使用的表达式形式,如“3 + 4 * 2”。

前缀表达式是运算符位于操作数之前的形式,例如“+ 3 * 4 2”。

后缀表达式则是运算符位于操作数之后的形式,例如“3 4 2 * +”。

3. 使用栈解决表达式求值问题在解决表达式求值问题时,我们可以利用栈的特性来简化计算过程。

具体步骤如下:3.1 将中缀表达式转换为后缀表达式我们需要将中缀表达式转换为后缀表达式,这样可以简化表达式的计算顺序。

具体转换规则如下:- 从左至右扫描中缀表达式的每个数字或符号。

- 如果是操作数,则直接输出。

- 如果是运算符,则弹出栈中所有优先级大于或等于该运算符的运算符,并将其压入栈中,然后压入该运算符。

- 如果是括号,则根据括号的不同情况进行处理。

通过以上规则,我们可以将中缀表达式转换为后缀表达式。

3.2 计算后缀表达式的值得到后缀表达式后,我们可以利用栈来计算其值。

具体步骤如下:- 从左至右扫描后缀表达式的每个数字或符号。

- 如果是操作数,则压入栈中。

- 如果是运算符,则弹出栈中的两个操作数进行相应的运算,并将结果压入栈中。

- 继续扫描直到表达式结束,栈中的值即为所求结果。

通过以上步骤,我们可以使用栈来解决表达式求值问题。

4. C语言代码实现以下是使用C语言实现栈来解决表达式求值问题的代码示例:```c#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct {int top;int capacity;int* array;} Stack;Stack* createStack(int capacity) {Stack* stack = (Stack*)malloc(sizeof(Stack));stack->capacity = capacity;stack->top = -1;stack->array = (int*)malloc(stack->capacity * sizeof(int)); return stack;}int isFull(Stack* stack) {return stack->top == stack->capacity - 1; }int isEmpty(Stack* stack) {return stack->top == -1;}void push(Stack* stack, int item) {if (isFull(stack)) return;stack->array[++stack->top] = item;}int pop(Stack* stack) {if (isEmpty(stack)) return -1;return stack->array[stack->top--];}int evaluatePostfix(char* exp) {Stack* stack = createStack(strlen(exp)); for (int i = 0; exp[i]; i++) {if (isdigit(exp[i])) {push(stack, exp[i] - '0');} else {int val1 = pop(stack);int val2 = pop(stack);switch (exp[i]) {case '+':push(stack, val2 + val1); break;case '-':push(stack, val2 - val1); break;case '*':push(stack, val2 * val1); break;case '/':push(stack, val2 / val1); break;}}}return pop(stack);}int m本人n() {char exp[] = "34*2+";printf("The value of s is d\n", exp, evaluatePostfix(exp));return 0;}```以上代码实现了栈的基本功能,并利用栈来计算后缀表达式的值。

C语言表达式求值

C语言表达式求值

C语言表达式求值
c语言有丰富的表达式,这是它的特点之一,表达式主要有4类,算术表达式,赋值表达式,逗号表达式,关系表达式1.算术表达式就是包含算术运算符(如+-/*%等)的表达式(不是语句,后面没有分号),如:a+b,a%b,a+b-c*d,3+5等,算术表达式的值就是最后算出的结果,如3+5这个表达式的值就是82.赋值表达式,就是含有赋值运算符=的表达式,如a=5,b=3,c='A'等,=左边的a,b,c称为左值,必须为变量,=右边的5,3,'A'称为右值,必须为常量,赋值表达式的值为右值,如a=3的值为3,c='A'的值为字母A的ascii码65(当然也可以认为它的值就是字母A)3.逗号表达式就是含有逗号的表达式,形式:表达式1,表达式2,表达式3.......如a,b,c3,5,7a=3,b=4,c=63,a=5,b=6等逗号表达式的值为,最右边的表达式的值,如3,4,5的值就是5,表达式
a=3,b=4,c=6的值就是表达式b=6的值,
由上述分析知,表达式b=6的值就是6,所以表达式
a=3,b=4,c=6的值就是64.关系表达式,指含有关系运算符
(如><>====<等)的表达式(其实也是算术表达式的一种)如
a>b,a>6,6>5,3<2,4==6等,如果表达式的关系是正确的,那么表达式的值为1,否则为0如6>5正确,表达式的值为1,3<2,和4==6错误,表达式的值为0当然可以细分为很多种表达式,不过主要也就是这几种的变型。

数据结构表达式求值c语言

数据结构表达式求值c语言

数据结构表达式求值c语言在C语言中,表达式通常由运算符和操作数组成。

运算符可以是算术运算符(如加减乘除)、关系运算符(如等于、不等于)或逻辑运算符(如与、或)。

操作数可以是变量、常量或其他表达式。

为了对表达式进行求值,我们需要将表达式转换为一种方便计算的形式。

常用的表达式形式有中缀表达式、后缀表达式和前缀表达式。

其中,后缀表达式也被称为逆波兰表达式,前缀表达式也被称为波兰表达式。

在表达式求值的过程中,我们可以使用栈这种数据结构来辅助计算。

栈是一种后进先出(Last In First Out,LIFO)的数据结构,可以用来保存运算符和中间结果。

我们可以通过以下步骤来求解一个后缀表达式:1. 创建一个空栈,用于保存操作数和中间结果。

2. 从左到右扫描后缀表达式的每个字符。

3. 如果遇到操作数,则将其压入栈中。

4. 如果遇到运算符,则从栈中弹出两个操作数,并根据运算符进行计算。

将计算结果压入栈中。

5. 重复步骤3和步骤4,直到扫描完所有字符。

6. 栈中最后剩下的元素即为表达式的求值结果。

下面是一个示例,演示如何使用后缀表达式求解一个简单的数学表达式:后缀表达式:"2 3 + 4 *"1. 创建一个空栈。

2. 从左到右扫描后缀表达式的每个字符。

- 遇到数字2,将其压入栈中。

- 遇到数字3,将其压入栈中。

- 遇到运算符+,从栈中弹出两个操作数2和3,计算2 + 3 = 5,并将结果5压入栈中。

- 遇到数字4,将其压入栈中。

- 遇到运算符*,从栈中弹出两个操作数5和4,计算5 * 4 = 20,并将结果20压入栈中。

3. 扫描完所有字符后,栈中最后剩下的元素20即为表达式的求值结果。

除了后缀表达式,我们还可以使用其他形式的表达式来进行求值。

前缀表达式的求值过程与后缀表达式类似,只是扫描的顺序从左到右变成了从右到左。

中缀表达式的求值过程比较复杂,需要使用算符优先级和括号来确定运算顺序。

在实际编程中,我们可以使用数组、链表或树等数据结构来表示和存储表达式。

c语言对字符串表达式求值小数运算

c语言对字符串表达式求值小数运算

c语言对字符串表达式求值小数运算在C语言中,你可以使用标准库中的函数来对字符串表达式求值。

这通常涉及到一些库函数,如`strtod()` 用于将字符串转换为浮点数,以及`eval()` 函数(尽管在C标准库中没有`eval()`,但一些第三方库提供此功能)。

下面是一个简单的示例,演示如何使用`strtod()` 函数将字符串表达式转换为浮点数,并进行计算:```c#include <stdio.h>#include <stdlib.h>#include <string.h>int main() {char expression[] = "3.14 + 2.718 * 2";char *endptr;double result;double num1 = strtod(expression, &endptr);if (endptr == expression) {printf("无法解析数字\n");return 1;}while (*endptr == ' ') {endptr++;}if (*endptr == '\0') {printf("表达式为:%s,结果为:%f\n", expression, num1);return 0;}double num2 = strtod(endptr, &endptr);while (*endptr == ' ') {endptr++;}if (*endptr == '\0') {result = num1 + num2;} else {result = num1 * num2;}printf("表达式为:%s,结果为:%f\n", expression, result);return 0;}```这个示例程序将解析并计算字符串表达式"3.14 + 2.718 * 2"。

C语言简单计算器原理——表达式求值(采用逆波兰表达式和栈结合)

C语言简单计算器原理——表达式求值(采用逆波兰表达式和栈结合)

C语⾔简单计算器原理——表达式求值(采⽤逆波兰表达式和栈
结合)
表达式的求解的关键是将其转换成逆波兰表达式(即后缀表达式,如1+2*3它的逆波兰表达式为123*+),在后缀表达式中已经考虑了运算符的优先级,
没有括号,只有操作数和运算符。

算术表达式转换成后缀表达式⽅法如下:
依次从键盘输⼊表达式的字符ch,对于每个ch:
(1)若ch为数字则直接将其放⼊后缀数组exp中并以#号标记数值串结束。

(2)若ch为"(",则直接将其压⼊字符栈op中。

(3)若ch为")",则将栈中"("以前的字符依次全部删除并将其放⼊后缀数组exp中,然后再将字符ch放⼊字符栈op中。

(4)若ch为"+"."-",则将栈中"("以前的运算符依次全部删除并将其放⼊后缀数组exp中,然后再将ch放⼊op栈中。

(5)若ch为"*"."/",则将栈顶连续的"*"."/"删除,并放⼊后缀数组exp中,然后将ch放⼊op栈中。

(6)若字符串str扫描完毕,则将栈中所有运算符删除并放⼊后缀数组exp,最后在后缀数组exp中便可得到后缀表达式。

在对后缀表达式求值时要⽤到⼀个数值栈st,在后缀数组exp中从头开始扫描,若是数字则将其放⼊数值栈中,
若遇到字符就进⾏两次退栈,并将运算结果再放⼊栈中,如此重复下去,最后当后缀数组扫描完后数值栈st的栈顶元素便是所要求的表达式的值。

数据结构(C语言版)课程设计报告表达式求值说明书

数据结构(C语言版)课程设计报告表达式求值说明书

数据结构(C语言版)课程设计报告表达式求值说明书XX大学数据结构课程设计说明书题目:表达式求值院系:计算机科学与工程学院专业班级:计算机班学号:学生姓名:指导教师:2021年X月X日XX大学课程设计(论文)任务书计算机科学与工程学院学号学生姓名专业(班级)设计题目表达式求值设计技术参数系统平台:Windows7/WindowsXP开发工具:VC++6.0设计要求(1)能够计算的运算符包括:加、减、乘、除、圆括号。

(2)能够计算的数要求在实数范围内。

(3)能执行多重括号嵌套运算。

(4)对于异常表达式给出错误提示。

工作量课程设计报告要求不少于3000字。

源程序要求不少于300行工作计划2021.11.21-12.01根据课程设计大纲的要求,查找相关资料,完成需求分析;2021.12.02-12.16进行系统的概要设计;2021.12.17-12.31进行系统的详细设计和源代码的书写;2021.01.01-01.17对系统进行调试分析,写出课程设计报告。

参考资料[1]何钦铭主编.C语言程序设计.北京:高等教育出版社,2021.[2]谭浩强编著.C程序设计(第四版).北京:清华大学出版社,2021.[3]严蔚敏,吴伟民编著.数据结构(C语言版)北京:清华大学出版社,2021.[4]严蔚敏,吴伟民编著.数据结构题集北京:清华大学出版社,2021.指导教师签字教研室主任签字2021年X月X日学生姓名:学号:专业班级:课程设计题目:表达式求值指导教师评语:成绩:指导教师:年月日XX大学课程设计(论文)成绩评定表目录1需求分析12概要设计12.1设计思路12.2存储结构设计12.3功能模块设计13详细设计14运行与测试15总结1参考文献2(要求:给出一级目录和二级目录,宋体,四号字,1.5倍行距,页码使用罗马数字,居中)(报告正文部分):(要求:正文部分一律用小四号字,宋体,行距20磅。

一级标题靠左,加粗。

二级大标题靠左,不加粗。

数据结构C语言版_栈实现表达式求值

数据结构C语言版_栈实现表达式求值
c=getchar();
break;
case'=':
Pop(&OPTR,&x); // 脱括号并接收下一字符
c=getchar();
break;
case'>':
Pop(&OPTR,&theta); // 退栈并将运算结果入栈
switch(theta)
{
case'+':
c=a+b+48;
break;
case'-':
c=a-b+48;
break;
case'*':
c=a*b+48;
break;
case'/':c=a/b+48;
}
return c;
}
// 算法3.4 P54
}SqStack; // 顺序栈
// 构造一个空栈S。
int InitStack(SqSt的存储空间
(*S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
default:
f='>';
}
}
return f;
}
// 判断c是否为运算符
int In(SElemType c)
{
switch(c)
{
case'+':
case'-':
case'*':

c语言顺序栈实现表达式求值

c语言顺序栈实现表达式求值

c语言顺序栈实现表达式求值下面是C语言顺序栈实现表达式求值的代码示例:```c#include <stdio.h>#include <stdlib.h>#define MAX_EXPR_LEN 100typedef struct {double* data; // 存储数据的数组指针int top; // 栈顶指针int maxSize; // 栈的最大容量} Stack;// 初始化栈void init(Stack* stack, int maxSize) {stack->data = (double*)malloc(maxSize * sizeof(double));stack->top = -1;stack->maxSize = maxSize;}// 判断栈是否为空int isEmpty(Stack* stack) {return stack->top == -1;}// 判断栈是否已满int isFull(Stack* stack) {return stack->top == stack->maxSize - 1;}// 入栈void push(Stack* stack, double value) {if (isFull(stack)) {printf("Stack is full.\n");return;}stack->data[++stack->top] = value;}// 出栈double pop(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}return stack->data[stack->top--];}// 获取栈顶元素double top(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}return stack->data[stack->top];}// 运算符优先级比较int priority(char op) {switch(op) {case '+':case '-':return 1;case '*':case '/':return 2;case '(':case ')':return 0;default:return -1;}}// 执行操作double operate(double operand1, double operand2, char op) { switch(op) {case '+':return operand1 + operand2;case '-':return operand1 - operand2;case '*':return operand1 * operand2;case '/':return operand1 / operand2;default:return 0;}}// 表达式求值double evaluateExpression(char* expression) {Stack operandStack; // 操作数栈Stack operatorStack; // 运算符栈init(&operandStack, MAX_EXPR_LEN);init(&operatorStack, MAX_EXPR_LEN);int i = 0;while (expression[i] != '\0') {if (expression[i] >= '0' && expression[i] <= '9') {// 处理数字double num = 0;while (expression[i] >= '0' && expression[i] <= '9') {num = num * 10 + (expression[i] - '0');i++;}push(&operandStack, num);} else if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*' || expression[i] == '/') {// 处理运算符while (!isEmpty(&operatorStack) && priority(expression[i]) <= priority(top(&operatorStack))) {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}push(&operatorStack, expression[i]);i++;} else if (expression[i] == '(') {// 处理左括号push(&operatorStack, expression[i]);i++;} else if (expression[i] == ')') {// 处理右括号while (top(&operatorStack) != '(') {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}// 弹出左括号pop(&operatorStack);i++;} else {i++;}}// 处理剩余的运算符while (!isEmpty(&operatorStack)) {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}double result = pop(&operandStack);return result;}int main() {char expression[MAX_EXPR_LEN];printf("请输入表达式:");fgets(expression, sizeof(expression), stdin);double result = evaluateExpression(expression);printf("表达式的结果为:%lf\n", result);return 0;}```使用该代码,可以实现对不带括号的四则运算表达式进行求值。

C语言_算术表达式求值_代码

C语言_算术表达式求值_代码

C语言_算术表达式求值_代码源代码://用来存储字符的结点类型typedef struct CharNode{char c;struct CharNode *next;}CharNode;//用来存储数的结点类型typedef struct IntNode{long double i;struct IntNode *next;}IntNode;//用来存储数的结点类型typedef struct Node{long double n;struct Node_ys_char *next;}Node;//用来存储运算符的结点类型typedef struct Node_ys_char{char c;struct Node_ys_char *next_c;struct Node *next;}Node_ys_char;char Precede(char x,char y)//运算符优先级判断{ int i,j;int from[5][5]={{0,0,-1,-1,0},{0,0,-1,-1,0},{1,1,0,0,1},{1,1,0,0,1},{0,0,-1,-1,0}};//定义一个二维数组存放算术符号的优先级switch(x){case '+':i=0;break;case '-':i=1;break;case '*':i=2;break;case '/':i=3;break;case '#':i=4;break;}switch(y){case '+':j=0;break;case '-':j=1;break;case '*':j=2;break;case '/':j=3;break;case '#':j=4;break;}if(from[i][j]==1)//说明运算符i的优先级比j的优先级高return '>';if(from[i][j]==-1)return '<';elsereturn '=';}//输入表达式,并对特殊情况做处理CharNode *CreatRegister(){CharNode *top,*p,*q,*e;top=(CharNode *)malloc(sizeof(CharNode)); p=q=top;scanf("%c",&p->c);scanf("%c",&p->c);if(q->c=='-'){p=(CharNode *)malloc(sizeof(CharNode)); p->c='0';p->next=q;top=p;p=q;}if(q->c=='('){e=(CharNode *)malloc(sizeof(CharNode)); e->c='0';p=(CharNode *)malloc(sizeof(CharNode)); p->c='+';e->next=p;p->next=q;p=q;top=e;}while(p->c!='#'){q=(CharNode *)malloc(sizeof(CharNode)); scanf("%c",&q->c);if((p->c=='(')&&(q->c=='-')){e=(CharNode *)malloc(sizeof(CharNode));e->c='0';e->next=q;p->next=e;p=q;}else{p->next=q;p=q;}}p->c='+';p->next=(CharNode *)malloc(sizeof(CharNode)); p->next->c='0';p=p->next;p->next=(CharNode *)malloc(sizeof(CharNode)); p->next->c='#';return top;}//将数与运算符分开,并将其他进制转化为10进制Node *StackChange(CharNode *top,int m){CharNode *p,*q;long double x=0,y=0;char a[10],b[10];int n=0,i=0,JiWei,max,min=47,mark_1=0,mark_2=0,h,k=0; Node *node,*head;Node_ys_char *node_char;switch(m){case 2:JiWei=2;max=50;break;case 8:JiWei=8;max=56;break;case 10:JiWei=10;max=97;break;case 16:JiWei=16;max=103;break;}p=q=top;while(p->c !='#'){while((q->c>min)&&(q->cc==46)) {if(q->c==46){mark_1=1;q=q->next;}if(mark_1==0){a[n]=q->c;q=q->next;n++;}if(mark_1==1){b[i]=q->c;q=q->next;i++;}}for(h=n-1;h>=0;h--){x=(a[n-h-1]-48)*pow(JiWei,h)+x;// }for(h=0;h<i;h++)< p="">{y=y+(b[h]-48)*pow(JiWei,(-(h+1)));//}node=(Node *)malloc(sizeof(Node));//node->n=x+y;mark_1=0;n=0;i=0;if(mark_2==1)node_char->next=node;node_char=(Node_ys_char *)malloc(sizeof(Node_ys_char)); node_char->c=q->c;node->next=node_char;node_char->next_c=NULL;node_char->next=NULL;if(q->c=='#'){node->next=(Node_ys_char *)malloc(sizeof(Node_ys_char));node->next->c='#';return head;}q=q->next;if(q->c<=min)while(q->c<=min){node_char->next_c=(Node_ys_char*)malloc(sizeof(Node_ys_char));node_char->next_c->c=q->c;q=q->next ;//node->next=node_char;node_char=node_char->next_c;node_char->next_c=NULL;node_char->next=NULL;}else{node->next=node_char;node_char->next_c=NULL;node_char->next=NULL;}p=q;n=0;x=0;y=0;if(mark_2==0){head=node;mark_2=1;}}return head;}//作只有加减乘除运算的表达式求值Node *Compute(Node *p){int mark=0;Node *m,*n;char max_char,min_char;m=n=p;while(p->next->c!='#'){max_char=n->next->c;n=n->next->next;min_char=n->next->c;if((Precede(max_char,min_char)=='<'||Precede(max_char,min _char)=='=')&&mark!=1) {m=n;}if(Precede(max_char,min_char)=='>'||mark==1){switch(m->next->c){case '+':m->n =m->n + n->n ;break;case '-':m->n =m->n - n->n ;break;case '*':m->n =m->n * n->n ;break;case '/':m->n =m->n / n->n ;break;}m->next=n->next;n=m;}if(m->next->c=='#'){m=n=p;mark=1;}}return m;}//求用户输入表达式的值Node *GetOutcome(Node *head){Node *p,*q,*R;Node_ys_char *m,*n,*t,*k;n=(Node_ys_char *)malloc(sizeof(Node_ys_char)); n->c='(';p=q=head;while((n->c!=')')&&(q->next->c!='#')){if(q->next->c=='('){m=q->next;k=m;}else if(q->next->next_c==NULL) q=q->next->next;else{m=q->next->next_c;k=q->next;// t=q->next;if(m->c=='('){t=k;k=m;}while(m->next_c!=NULL){m=m->next_c;if(m->c=='('){t=k;k=m;}}q=m->next ;}if(q->next->c==')'){n=q->next;}}if(n->c==')'){p=k->next;q->next->c='#';R=Compute(p);t->next =R;t->next_c=NULL;R->next=n->next_c;GetOutcome(head);}else{R=Compute(head);return R;}}main(){int m;//进制char a;CharNode *top_1;Node *top_2,*R;printf("\n\n");printf("███████████████████████████████████████\n");printf("████\n");printf("██表达式求值系统██\n");printf("████\n");printf("███████████████████████████████████████\n");printf("本程序可分别进行2进制,8进制,10进制,16进制的加减乘除运算:\n");loop:printf("...............请输入进制..............\n");printf("你选的进制为:");scanf("%d",&m);printf("请输入表达式,表达式请以#结尾:\n");top_1=CreatRegister();//录入表达式,并对特殊情况作处理,将头指针带回;top_2=StackChange(top_1,m);//进制转换,将数与运算符分开,将头指针带回;R=GetOutcome(top_2);得出结果printf("运算结果的十进制形式为:\n");printf("%lf",R->n);printf("\n继续进行运算请输入y否则退出:\n");scanf("%c",&a);scanf("%c",&a);if(a=='y'||a=='Y')goto loop;}</i;h++)<>。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

/*表达式求值,输入一个表达式,如1+2*3#,程序可计算出结果为7支持以下符号:+ - * / ( ) ^ .可以计算整数、小数其中^表示次方,2^5表示2的5次方*//*头文件*/#include <>#include <>#include <>#include <>#include <>/*宏定义*/#define INIT_STACK_SIZE 100#define SET_NUM 8#define N 100/*字符优先级表*/unsigned char prior[SET_NUM][SET_NUM] ={/* '+' '-' '*' '/' '(' ')' '#' '^' *//*'+'*/'>', '>', '<', '<', '<', '>', '>', '<',/*'-'*/'>', '>', '<', '<', '<', '>', '>', '<',/*'*'*/'>', '>', '>', '>', '<', '>', '>', '<',/*'/'*/'>', '>', '>', '>', '<', '>', '>', '<',/*'('*/'<', '<', '<', '<', '<', '=', ' ', '<',/*')'*/'>', '>', '>', '>', ' ', '>', '>', '>',/*'#'*/'<', '<', '<', '<', '<', ' ', '=', '<',/*'^'*/'>', '>', '>', '>', '<', '>', '>', '>'};unsigned char priorSet[SET_NUM] = {'+', '-', '*', '/', '(', ')', '#', '^'};/*结构体定义,这是用来存放字符的栈*/typedef struct{char *base;char *top;int stacksize;} SqStackC;/*结构体定义,这是用来存放数字的栈*/typedef struct{double *base;double *top;int stacksize;} SqStackN;void initStackN(SqStackN &);void initStackC(SqStackC &);void pushN(SqStackN &, double);void pushC(SqStackN &, double);void popN(SqStackN &, double &);void popC(SqStackN &, double &);double calculate(double, char, double);int findInSet(char);char compare(char, char);void getSolution();/*主函数*/void main(){getSolution();}/*初始化数字栈*/void initStackN(SqStackN &S){= (double*) malloc(INIT_STACK_SIZE * sizeof(double));= ;= INIT_STACK_SIZE;}/*初始化字符栈*/void initStackC(SqStackC &S){= (char*) malloc(INIT_STACK_SIZE * sizeof(char));= ;= INIT_STACK_SIZE;}/*向数字栈中存放数字*/void pushN(SqStackN &S, double x){if >=*++) = x;}/*向字符栈中存放字符*/void pushC(SqStackC &S, char x){if - >=return;*++) = x;}/*从数字栈中取出数字*/void popN(SqStackN &S, double &x){if ==return;x = *;}/*从字符栈中取出字符*/void popC(SqStackC &S, char &x){if ==return;x = *;}/*这个函数返回a operation b的值。

假如operation为'+',则返回a+b的值*/ double calculate(double a, char operation, double b){/*判断operation,返回对应的计算结果*/switch (operation) {case '+':return a + b;case '-':return b - a;case '*':return a * b;case '/':return b / a;case '^':return pow(b, a);default:}}/*查找字符c在priorSet中的什么位置*//*priorSet是所支持的所有字符的集合*/int findInSet(char c){int i;for (i = 0; i < SET_NUM; i++) {if (priorSet[i] == c)return i;}return -1;}/*比较optrtop和c的优先关系*/char compare(char optrtop, char c){int i, j;/*从priorSet中取出optrtop和c的位置*/i = findInSet(optrtop);j = findInSet(c);/*如果返回值中有-1表示这个符号不支持,结束程序*/if (i == -1 || j == -1) {printf("不支持的符号类型\n");exit(0);}/*否则返回二者优先级关系*/elsereturn prior[i][j];}/*取得计算结果*//*解释下代码处理数字的原理:假如输入为10+*3-2#循环会从这个字符串第一个位置开始,也就是1如果当前字符是个数字,则要把这个数字从字符串里取出来这个时候涉及两个问题,一是数字可能是大于10的整数,二是可能有小数。

处理方法是这样的:当遇到数字,先将数字保存在n上,判断下一个字符是数字还是运算符如果是数字,则将n乘以10加上这个数字,这样即可以处理大于10的数字。

如果遇到运算符,就退出循环去处理运算符如果遇到的是小数点,表示这个数字是小数。

小数不会立刻计算出来,而是先将小数点忽视掉,将整数计算出。

比如会先计算成22变量j和begin在遇到小数点时候用来计算小数点后面有几个数字,即这个小数有多少位。

当begin = 1时候,表示现在要计算小数点后的数字位数。

这时候j会在每次循环加1这样计算后,n = 22, j = 1;此时算 n = n / pow(10, j);即将n缩小10的j次方。

就变成了*/void getSolution(){/*operation是当前的运算符*/char operation;/*temp是输入的字符串*/char temp[N];/*i是循环变量,j和begin用来控制什么时候计算出小数*/int i = 0, j = -1, begin = 0;/*sum是每次的计算结果,a和b是从数字栈中取出的数字,n用来存放从字符串中取出的数*/double sum, a, b, n;/*定义堆栈并初始化*/SqStackC OPTR;SqStackN OPND;initStackC(OPTR);initStackN(OPND);/*向字符栈中压入#,标志开始*/pushC(OPTR, '#');/*获得输入*/printf("请输入一个表达式,输入#结束\n");gets(temp);/*开始计算,当遇到#表示结束*/while (temp[i] != '#' || * - 1) != '#') {/*如果当前字符是个数字字符*/if (temp[i] >= '0' && temp[i] <= '9') {/*重置n为0*/n = 0;/*当当前字符是数字或者小数点*/while (temp[i] >= '0' && temp[i] <= '9' || temp[i] == '.') {/*如果是小数点,begin=1,表示要从字符串中取出一个小数*/if (temp[i] == '.')begin = 1;/*否则作为整数取出*/elsen = n * 10 + temp[i] - '0';/*如果begin不为0,表示遇到了一个小数点,表示需要合并为小数*//*j表示这个小数的小数点后面有几位*/if (begin != 0)j++;/*循环变量加1*/i++;}/*如果j不为-1,则表示这是个小数,n是整数结果,除以pow(10,j)则变成了小数*/if (j != -1)n = n / pow(10, j);/*将数字压入栈*/pushN(OPND, n);/*重置j和begin的值*/j = -1;begin = 0;}else {/*如果当前字符不是数字,比较栈顶字符和当前字符优先级,根据优先级处理*/switch (compare(* - 1), temp[i])) {/*如果栈顶字符优先级大,则可以取出计算*/case '>':/*取出字符栈顶运算符,和数字栈顶的两个数字*/popC(OPTR, operation);popN(OPND, a);popN(OPND, b);/*计算结果*/sum = calculate(a, operation, b);/*结果入栈*/pushN(OPND, sum);break;/*如果优先级小*/case '<':/*入栈,继续循环*/pushC(OPTR, temp[i]);i++;break;/*如果优先级相等*/case '=':/*优先级相等只有两个可能,#相遇或者()相遇,这情况只要把字符出栈丢掉就可以了,因为已经没用了*/popC(OPTR, operation);i++;break;}}}/*输出结果*/printf("结果为:%lf\n", * - 1));}。

相关文档
最新文档