数学表达式计算(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语言实现)

一、设计思想计算算术表达式可以用两种方法实现: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语言程序设计 简单的算术运算和表达式(3.1.2)--3.1节-3.5节

13
printf("area = %f\n", area);
14 }
【例题解析】本题用宏常量代替了程序中多次出现的常数,提高了程序的可读性和可维
护性。
【例 3.5】使用 const 常量定义,编程从键盘输入圆的半径 r,计算并输出圆的周长和面
积。
1 #include <stdio.h>
2 main()
a)(s
b)(s
c)
,s=
1பைடு நூலகம்2
(a
b
c)
试编程从键盘输入 a,b,c 的值(假设 a,b,c 的值可以保证其构成一个三角形),计算
并输出三角形的面积。
程序如下:
1 #include <stdio.h>
2 #include <math.h>
3 main()
4{
5
float a, b, c, s, area;
3{
4
const double pi = 3.14159; /* 定义实型的const常量pi */
5
double r;
6
double circum;
7
double area;
8
printf("Input r:");
9
scanf("%lf", &r);
10
circum = 2 * pi * r;
11
6
printf("(float)(m/2) = %f\n", (float)(m/2));
7
printf("(float)m/2 = %f\n", (float)m/2);
数学公式的c语言表达式

数学公式的c语言表达式数学公式是我们日常生活和工作中不可或缺的一部分。
在计算机编程中,我们也需要使用数学公式来解决一些问题。
而这些数学公式需要通过c语言表达式来实现。
本文将介绍一些常见的数学公式及其c语言表达式,供大家参考。
一、基本运算符在c语言中,常见的数学运算符包括加号(+)、减号(-)、乘号(*)、除号(/)和求模运算符(%),它们的优先级从高到低依次为:乘、除、求模、加、减。
二、三角函数1.正弦函数在c语言中,正弦函数可以使用math库中的sin()函数实现。
例如计算30度的正弦值,可以用以下代码:#include <stdio.h>#include <math.h>int main(){double angle = 30;double radian = angle * M_PI / 180;double sin_value = sin(radian);printf('sin(30) = %f', sin_value);return 0;}2.余弦函数在c语言中,余弦函数可以使用math库中的cos()函数实现。
例如计算45度的余弦值,可以用以下代码:#include <stdio.h>#include <math.h>int main(){double angle = 45;double radian = angle * M_PI / 180;double cos_value = cos(radian);printf('cos(45) = %f', cos_value);return 0;}3.正切函数在c语言中,正切函数可以使用math库中的tan()函数实现。
例如计算60度的正切值,可以用以下代码:#include <stdio.h>#include <math.h>int main(){double angle = 60;double radian = angle * M_PI / 180;double tan_value = tan(radian);printf('tan(60) = %f', tan_value);return 0;}三、指数和对数函数1.指数函数在c语言中,指数函数可以使用math库中的exp()函数实现。
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语言表达式运算1.引言1.1 概述概述部分旨在介绍C语言表达式运算的基本概念和重要性。
在C语言中,表达式运算是程序中最基本、最常用的操作之一。
通过对表达式的运算,程序能够实现各种功能和逻辑判断。
C语言的表达式由操作数和运算符组成,通过特定的运算符以及它们的优先级和结合性,可以实现算术运算、逻辑运算、位运算和条件运算等各种类型的运算。
C语言表达式运算的结果是一个值,这个值可以被赋给变量,或者用于控制程序的流程。
表达式运算在编程中起着举足轻重的作用。
它可以用于简单的数值计算,例如加减乘除等算术运算。
同时,表达式运算也是实现复杂逻辑判断的基础,例如比较运算、逻辑运算和条件运算。
C语言的表达式运算还可以用于位运算,对二进制数值的位进行操作,实现各种位操作的需求。
了解和掌握表达式运算在C语言中的特性和规则,对于进行程序设计和算法实现至关重要。
在编写高效、可靠且易于理解的代码时,正确使用表达式运算符,合理选择表达式的结构和运算次序,都是必不可少的。
同时,对于程序调试和错误排除也有着重要的作用,通过对表达式运算过程的观察和分析,可以帮助我们找出代码中隐藏的错误和逻辑漏洞。
总之,C语言的表达式运算是程序设计中的重要组成部分,它涵盖了各种运算类型,能够帮助我们实现各种功能和逻辑判断。
深入理解和掌握表达式运算的特性和规则,对于编写高质量的代码和实现优化的算法来说是至关重要的。
在接下来的部分中,我们将详细介绍表达式的基本概念和运算符,并通过实例来展示其在实际编程中的应用。
1.2文章结构文章结构部分的内容应该包括对于整篇文章的组织和布局的介绍。
下面是一个可能的写作内容示例:在本文中,我们将按照以下结构来进行讨论和分析C语言表达式的运算。
文章主要包含三个部分:引言、正文和结论。
在引言部分,我们将对本文要探讨的主题进行概述,简要介绍C语言表达式运算的背景和基本概念,并明确文章的目的。
通过引言,读者可以对本文的主题和目标有一个初步的了解。
绝对值c语言表达式

绝对值c语言表达式在C语言编程中,绝对值是常用的数学运算之一。
绝对值表示一个数与零之间的距离,其结果总是非负数。
在C语言中,我们可以使用各种方法来表达和计算绝对值。
本文将介绍几种在C语言中表达绝对值的常见方法,并给出相应的代码示例。
一、使用条件语句表达绝对值最常见的表达绝对值的方法是使用条件语句。
在C语言中,我们可以使用if-else语句来判断给定数的符号,并根据其符号返回相应的绝对值。
```c#include <stdio.h>int main() {int num;printf("请输入一个整数:");scanf("%d", &num);if (num < 0) {num = -num;}printf("%d的绝对值是:%d\n", num, num);return 0;}```在上述代码中,我们通过读取用户输入的整数,并使用if-else语句判断该数的符号。
如果数小于0,则将其取反得到其绝对值;如果数大于等于0,则直接使用该数作为绝对值。
最后,我们将结果打印输出。
二、使用条件运算符表达绝对值除了使用if-else语句外,还可以使用条件运算符(三目运算符)来表达绝对值。
条件运算符可以在一个表达式中根据条件的结果选择不同的返回值。
```c#include <stdio.h>int main() {int num;printf("请输入一个整数:");scanf("%d", &num);num = num < 0 ? -num : num;printf("%d的绝对值是:%d\n", num, num);return 0;```在上述代码中,我们使用条件运算符(?:)判断给定数的符号。
如果数小于0,则返回其相反数(即取反),否则直接返回该数。
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语言表达

它们可与数据类型结合起来分类。例如,可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。在程序中,常量可以不经说明而直接引用,而变量则必须先定义后使用。
02
对于基本数据类型量,按其取值是否可改变又分为常量和变量两种。
03
2.1.2 常量与变量
2.1 基本数据类型
0 4
• 运算符与表达式
单击此处添加文本具体内容,简明扼要的阐述您的观点。
任务可以分解为两部分: 变量的定义及赋值。 数学算式转换成C语言表达式。
在实际编程中,有时会对不同数据类型的数据进行运算,以及计算一些数学算式的值。本章要完成的任务是:已知整型变量a、b、c的值,根据以下算式求y的值。
本章任务
2.2 整 型 数 据
2.2.1 整型常量
整型常量就是整常数。在C语言中,使用的整常数有八进制、十六进制和十进制3种,使用不同的前缀来相互区分。除了前缀外,C语言中还使用后缀来区分不同长度的整数。
1. 八进制整常数 八进制整常数必须以0开头,即以0作为八进制数的前缀。数码取值为0~7。如0123表示八进制数123,即(123)8,等于十进制数83,即1*82+2*81+3*80=83;-011表示八进制数-11,即(-11)8,等于十进制数-9。 (1) 以下各数是合法的八进制数: 015(十进制为13) 0101(十进制为65) 0177777(十进制为65535) (2) 以下各数是不合法的八进制数: 256(无前缀0) 0382(包含了非八进制数码8)
符号常量在使用之前必须先定义,其一般形式为: #define 标识符 常量
2.1 基本数据类型
2.1.2 常量与变量
【例2.1】符号常量的使用。程序代码如下:
算术表达式计算的实现(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 .  ̄ 、数组、 后缀 中缀表示等知识。 【 关键 词】后缀 ;中缀 ;函数;结构体
C语言实现数学表达式运算

C语⾔实现数学表达式运算本⽂实例为⼤家分享了C语⾔实现数学表达式运算的具体代码,供⼤家参考,具体内容如下数字要⼀个⼀个取出放在内存中,根据相邻前后2个计算符号,判断是否要取出数字进⾏计算,2个数字的计算值重新放在内存中且顺序放置。
考虑使⽤栈这种数据结构去保存数字和符号,⽤2个栈,1个栈保存数字,⼀个栈保存运算符号。
(1)如何判断前后2个运算符的优先级关系(2)如何字符转换为数字因键盘输⼊的内容为字符类型,需要判断输⼊的字符类型且进⾏必要转换ASCII码表,表头依次为:⼆进制⼗进制⼗六进制字符(3)如何判断表达式处理完毕默认先预置⼀个符号#,输⼊内容2 * 3 * ( 1 + 2)# ,当符号栈内为#,且当前处理的字符为#。
则表达式处理完毕。
1234567891011 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42#define _CRT_SECURE_NO_DEPRECATE#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 #include <stdlib.h>#include <stdio.h>#include "myStack.h"// 判断是否操作符int ifOp(char c) {switch(c) {case'+':return1;case'-':return1;case'*':return1;case'/':return1;case'(':return1;case')':return1;case'#':return1;default:break;}return0;}int findOffset(char* str,char c,int len) {for(int i = 0; i < len;i++) {43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 if(str[i] == c) {return i;}}return-1;}//判断任意相继出现的2个运算符的优先级char yxji(char op1,char op2) {char ops[] = "+-*/()#";char oplist[7][7] = {">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<=&",">>>>&>>","<<<<<&="};int len = sizeof(ops) / sizeof(char);return oplist[findOffset(ops,op1, len)][findOffset(ops, op2, len)]; }//基础运算 a-第1个数 b-第2个数void baseOp(char op,int a,int b,int* value) {printf("baseOp %d %c %d",a,op,b);//int value = 0;//int* p = &value;switch(op) {case'+':*value = a + b;break;case'-':*value = a-b;break;case'*':*value = a*b;break;case'/':*value = a/b;break;default:printf("运算符不合法");exit(1);}}//转换字符为数字void transValue(char c,int* v) {if(c > 47 && c < 58) {*v = (c - 48);}}void printstack(MyStack * stack1,MyStack * stack2) {int len1 = myListGetSize(stack1);int len2 = myListGetSize(stack2);printf("stack1值:");for(int i = 0; i < len1;i++) {char* m = (char*)myListGetDataAt(stack1,i );printf("%c ", *m);}printf("\nstack2值:");for(int i = 0; i < len2; i++) {int* m = (int*)myListGetDataAt(stack2, i);printf("%d(%p) ", *m,m);}printf("\n");}// 计算,该⽅法只能对数字 0-9 运算(可掌握栈、指针的使⽤)105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166// 2*3*(1+2)#void calculate(char bds[]) {int i = 0;char flag = '#';MyStack* stack1 = createMyStack();//stack1中放运算符myStackPush(stack1, &flag);MyStack* stack2 = createMyStack();//stack2中放数字//char c = bds[i]; // 等价于*(bds+i)while(bds[i] != '#'|| *(char*)myStackGetTop(stack1)!='#') {printstack(stack1,stack2);if(!ifOp(bds[i])) {/** 这种写法不⾏!int vv = 0;transValue(bds[i], &vv)*/int* vu = (int*)malloc(sizeof(int));transValue(bds[i], vu);printf("is number:%d\n", *vu);//打印出数字myStackPush(stack2, vu);i++;}else{printf("is fuhao:%c\n", bds[i]);char* op1 = (char*)myStackGetTop(stack1);printf("top1 op:%c\n",*op1);if(*op1 == '#') {myStackPush(stack1, &bds[i]);i++;continue;}char res = yxji(*op1, bds[i]);printf("yxji:%c\n",res);switch(res) {case'>':{char* curop = (char*)myStackPop(stack1);//取出当前运算符 printf("top2 op:%c\n", *op1);int* b = (int*)myStackPop(stack2);//第2个运算数int* a = (int*)myStackPop(stack2);//第1个运算数/** 这种写法不⾏!int value = 0;baseOp(*curop,transValue(*a), transValue(*b),&value); */int* value = (int*)malloc(sizeof(int));baseOp(*curop, *a, *b, value);printf("=%d\n", *value);myStackPush(stack2, value);break;}case'<':myStackPush(stack1, &bds[i]);i++;break;case'=': {printf("()==");myStackPop(stack1);//取出右括号 (i++;break;}default:printf("表达式错误!");exit(1);}}}int* valueRes = (int*)myStackPop(stack2);printf("计算结果值为:%d\n",*valueRes);freeMyList(stack1);freeMyList(stack2);}167168169170171172173174175176177178179180181182int main() {printf("输⼊表达式:\n");char bds[50];scanf("%s",bds);// 数组变量名,传⼊的相当于是数组第⼀个元素的地址。
C语言实现表达式计算

一、设计思想两种算法首先都要建立两个栈,一个是存放操作数的数栈OdStack,一个是存放运算符的符栈OpStack。
数栈采用double型的用来存放浮点数,符栈采用char型的用来存放运算符,由于考虑到运算符有优先级的问题,所以事先做了一个Type用来存储运算符的优先级。
栈建立好了之后做栈的相关操作,初始化栈,入栈,出栈,看栈顶。
其中入栈要判满,出栈和看栈顶要判空。
中缀转后缀再计算的算法。
此算法的基本思路是先将中缀表达式转换成后缀表达式,之后再利用后缀表达式的算法对表达式进行计算。
首先,用一个char数组将中缀表达式读入,对数组中的每一个元素进行处理,区分哪些是数,哪些是运算符。
如果是数元素(或小数点元素),则依次存入用来存储后缀表达式的char数组,直到一个整合数存完之后用空格将其与后面的元素分开。
如果是运算符元素,则根据当前运算符的优先级和栈里面的运算符的优先级进行处理。
如果栈内元素的优先级小于当前元素的优先级或者栈内为空,则将当前运算符入栈;如果栈内元素的优先级大于等于当前元素的,则依次将出栈元素存入后缀表达式,并用空格将其与后面的元素分开,直到栈内元素的优先级小或者栈内为空。
对于左括号来说,无条件进栈,并只在有右括号出现的时候才有可能出栈。
对于右括号来说,无条件让栈内元素出栈,直到左括号出栈。
依次将每个元素进行处理直到中缀表达式索引完毕。
至此,已经实现了将中缀表达式转换成了后缀表达式,在数组的最后加上结束符以便下一步的调用。
第二步,读出后缀表达式并进行计算。
如果索引到空格则将索引标志后推1位。
之后要先对char型的数字元素进行整合,从后缀表达式中依次取出数字元素(连同小数点)存入一个新的char型数组,直到一整个数取完后通过atof函数将char型转换成浮点型存入数栈,并将新数组初始化用来存储下一个数。
如果是索引到运算符,则在数栈中出栈两个数字与当前运算符进行运算,先出栈的数字放在运算符后面,后出栈的数字放在运算符的前面,将运算以后的结果再次存入数栈。
数据结构表达式求值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语⾔简单计算器原理——表达式求值(采⽤逆波兰表达式和栈
结合)
表达式的求解的关键是将其转换成逆波兰表达式(即后缀表达式,如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语言代码多项式是代数学中常见的一种数学表达式形式,通常表示为:P(x) = a0 + a1*x + a2*x^2 + a3*x^3 + ... + an*x^n其中a0, a1, a2,...,an是多项式P(x)的系数,x是变量,n是多项式的次数。
在实际的编程开发中,我们经常需要实现多项式的加法和乘法计算。
下面我们将介绍如何使用C语言来实现多项式的加法和乘法计算。
一、多项式的表示与存储在C语言中,可以使用结构体来表示多项式,并使用数组来存储多项式的系数。
假设我们要表示一个最高次数为n的多项式,可以定义结构体如下:```ctypedef struct {int coeff[MAX_SIZE]; // 存储多项式系数的数组int degree; // 多项式的最高次数} Polynomial;其中MAX_SIZE是一个常数,用来表示多项式的最大阶数。
在实际使用中,可以根据需要进行调整。
二、多项式的加法多项式的加法实质上是将两个多项式的对应系数相加,并将结果存储在一个新的多项式中。
下面是多项式加法的C语言代码实现:```cPolynomial addPolynomial(Polynomial poly1, Polynomial poly2) {Polynomial result;int i;// 确定结果多项式的最高次数result.degree = (poly1.degree > poly2.degree) ?poly1.degree : poly2.degree;// 将对应系数相加for (i = 0; i <= result.degree; i++) {result.coeff[i] = poly1.coeff[i] + poly2.coeff[i];return result;}```以上代码通过遍历多项式的系数数组,将对应位置的系数相加,并将结果存储在result中。
e的y方c语言表达式

e的y方c语言表达式
e的y方c语言表达式
在C语言中,我们可以使用数学库中的pow()函数来计算一个数的幂。
因此,要计算e的y次方,我们可以使用以下代码:
#include <stdio.h>
#include <math.h>
int main() {
double e = exp(1); // 计算自然常数e
double y = 2; // y的值
double result = pow(e, y); // 计算e的y次方
printf("e的%.0f次方是%.4f", y, result); // 输出结果
return 0;
}
在上面的代码中,我们首先使用exp()函数计算自然常数e的值,然后使用pow()函数计算e的y次方。
最后,我们使用printf()函数将结果输出到屏幕上。
需要注意的是,由于计算机中存储的是二进制数,因此在进行浮点数
运算时可能会出现精度误差。
因此,我们在输出结果时使用了%.4f的
格式控制符,保留小数点后4位,以避免精度误差对结果的影响。
另外,如果我们需要计算其他数的幂,也可以使用pow()函数。
例如,要计算2的3次方,可以使用以下代码:
double x = 2; // x的值
double n = 3; // n的值
double result = pow(x, n); // 计算x的n次方
总之,使用pow()函数可以方便地计算任意数的幂,包括e的y次方。
在进行浮点数运算时,需要注意精度误差的问题,以避免影响计算结
果的准确性。
c语言03 运算符及表达式

强制类型转换
用类型符号把表达式值转换为指定类型 格式:(类型名)表达式
如: (int)(a+b),(float)c;
注意只影响结果,不影响操作数
运算符优先级
归类
元素 单目运算符 算数运算符 移位运算符 关系运算符 位逻辑运算符 逻辑运算符
运算符
( ) [] -> . ! ~ ++ * / % + << < == & && || >> <= != | ^ >= > -(type) * & sizeof
– a>b?c:d<3?e:f, 等同于a>b?c:(d<3?e:f)
位运算
• 位运算是对操作数二进制位的运算 • &(按位与)、|(按位或)、^(按位异或) 、~(按 位取反) • <<(算术左移)低位补零 • >>(算数右移)高位补符号位数字
表达式 值 表达式 值
5&7(101B&111B=101B)
• •
赋值运算符优先级仅高于”,”运算符,方向从右向左 当=两侧类型不一致时,右侧自动转化成左侧类型
– – 低类型向高类型转化时会自动扩展字节,而值不变,扩充对于整数类,扩充字节填充符号位 数字,正数填0,负数填1 高类型向低类型转化时,只从低字节截取
• #include "stdio.h" • void main(){ • short a=0x12345678; • printf("%x\n",a); • }
优先级与计算顺序
• 优先级只决定操作数先与谁进行运算 • 同优先级由结合方向决定先与谁结合 • 而表达式是从左向右扫描的,一旦发现后面的 运算符低于或等于前者则前面将运算出结果
x的绝对值c语言表达式

x的绝对值c语言表达式计算x的绝对值是一项基本的数学运算,在编程中也是非常常见的操作。
在C语言中,可以使用条件表达式来实现对x的绝对值的计算。
下面我将逐步介绍如何使用C语言来表达x的绝对值,并探讨一些与绝对值相关的概念。
首先,让我们来了解一下绝对值的概念。
在数学上,绝对值表示一个数离零点的距离,它是一个非负数。
对于实数x,如果x大于或等于零,则它的绝对值等于它本身;如果x小于零,则它的绝对值等于它的相反数。
即,绝对值函数可以用如下公式表示:x = x (x >= 0) 或x = -x (x < 0)。
在C语言中,我们可以使用条件表达式来实现绝对值函数。
条件表达式是一种可以根据条件的真假来选择执行的不同代码的结构。
它的基本形式为:condition ? expression1 : expression2;其中,condition是一个逻辑表达式,expression1和expression2是两个可以执行的表达式。
现在让我们编写一个C语言表达式来计算x的绝对值。
首先,我们需要定义一个变量x来表示要计算绝对值的数值。
可以使用int类型或者float类型来声明这个变量,具体取决于我们希望计算整数还是浮点数的绝对值。
然后,我们可以使用条件表达式来判断x的正负,并分别返回x和-x来实现绝对值的计算。
代码如下:c#include <stdio.h>int main() {int x;printf("请输入一个数:");scanf("d", &x);int abs_x = x >= 0 ? x : -x;printf("d的绝对值是d\n", x, abs_x);return 0;}在这个代码中,我们首先使用printf函数输出一个提示,让用户输入一个数值。
然后使用scanf函数读取用户输入的数值,并将其赋值给变量x。
c语言:运算符和表达式

//把常量 5 存储到变量 a 的存储空间的过程,叫做给变量 a 初始化。
printf(“%d\n”,a+5);
//10
printf(“%d\n”,a);
//5
//a+5 这个数学表达式运算之后,并不会修改 a。
算数表达式的值:相关数学运算的结果。
printf(“%d,%d,%d,%d,%d”,5+3,5-3,5*3,5/3,5%3); //8 2 15 1 2
//个位,十位,百位
scanf a;
bit0=a%10;
bit1=a/10%10;
bit2=a/100
if(a%7==0||bit0==7||bit1==7||bit2=7)
printf(“yes\n”);
【注】与和或,特点 可以连与(有一个为假,值为假),可以连或(有一个为真,值为真)
十个表达式连与,表达式 4 为假,表达式 5 以后都不计算。 十个表达式连或,表达式 4 为真,表达式 5 以后就不计算。 int a=-3; if((a++<0)&&(a++<0)&&(a++<0)&&(a++<0)&&(a++<0)&&(a++<0)) {
b=a; a++;
printf(“%d%d\n”,a,b);
10
int a=0,b;
b=++a;
++a; b=a;
printf(“%d%d\n”,a,b);
11
功能:a++,++a 都是自增运算符,功能都是将 a+1。
c语言 算术表达式

c语言算术表达式算术表达式是计算机编程中常用的一种表达方式,通过使用运算符和操作数来表示各种数学运算。
C语言是一种广泛应用的编程语言,也支持算术表达式的使用。
本文将介绍C语言中算术表达式的基本概念和使用方法。
一、算术运算符在C语言中,常见的算术运算符有加法运算符(+)、减法运算符(-)、乘法运算符(*)、除法运算符(/)和取余运算符(%)。
这些运算符用于执行基本的四则运算操作。
1. 加法运算符(+)用于将两个操作数相加,例如:a + b。
2. 减法运算符(-)用于将第一个操作数减去第二个操作数,例如:a - b。
3. 乘法运算符(*)用于将两个操作数相乘,例如:a * b。
4. 除法运算符(/)用于将第一个操作数除以第二个操作数,例如:a / b。
5. 取余运算符(%)用于获取两个操作数相除的余数,例如:a % b。
二、算术表达式的使用在C语言中,可以将算术表达式用于赋值语句、条件语句和循环语句等多种语句中。
下面分别介绍这些语句中算术表达式的使用方法。
1. 赋值语句赋值语句用于将一个值赋给一个变量。
可以使用算术表达式来计算赋值的值。
例如:int a = 10;int b = 5;int c = a + b; // 将a和b的和赋给c2. 条件语句条件语句用于根据条件的真假执行不同的代码块。
可以使用算术表达式作为条件。
例如:int a = 10;int b = 5;if (a > b) {printf("a大于b\n");} else {printf("a小于等于b\n");}3. 循环语句循环语句用于重复执行一段代码。
可以使用算术表达式来控制循环的次数。
例如:int i;for (i = 0; i < 10; i++) {printf("%d\n", i);}三、注意事项在使用算术表达式时,需要注意以下几点:1. 运算符的优先级:不同的运算符有不同的优先级,需要注意运算符的优先级,可以使用括号来改变运算的顺序。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、设计思想计算算术表达式可以用两种方法实现: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,扫描结束。
此时看操作符栈是否为空,若不为空,出栈,再从值栈中取出两个数值进行计算,将其结果存入值栈,一直进行此操作,直到操作符栈为空。
此时把值栈中的数值取出,即为所得的最终计算结果。
二、算法流程图第一种算法:中缀转后缀算法其主函数流程图为:返回计算结果图1 主函数算法流程图中缀转后缀算法流程图如下:放入exp数组中图2 中缀转后缀算法流程图计算后缀表达式流程图如下:图3 后缀表达式计算流程图第二种算法:两个栈算法其主函数流程图为:返回计算结果图4 主函数算法流程图直接计算数学表达式流程图如下:图5 直接计算表达式流程图三、源代码下面给出的是用中缀转后缀算法实现的程序的源代码:#include<stdio.h>#include<string.h>#include<math.h>#include<stdlib.h>#define MAXSIZE 100 //定义宏,数组最大长度为100//函数实现中缀转后缀,将存储数学表达式的数组str传参进来,exp存储后缀表达式void trans(char str[],char exp[]){struct{char data[MAXSIZE];//用来存放操作符int top;//数组下标}op;//用结构体创建操作符栈char ch;int i=0,j=0,tempi=0;op.top=-1;//给操作符栈初始化,令下标为-1while(ch!='\0'){ch=str[i]; //取str数组的第i个元素赋值给chif((ch>='0'&& ch<='9') || ch=='.')//对数值操作{tempi=i;//若ch为数字或小数点,将其下标值赋给临时下标tempi//依次向后扫描str数组,若一直为数字,跳入while循环while((ch>='0' && ch<= '9') || ch == '.'){tempi++;exp[j]=ch;//将数字存入exp数组中j++;ch=str[tempi];//取str数组中下标为tempi的元素赋给ch}exp[j]='#';j++;//用#做分隔符,将数值分隔开i=tempi;//跳出循环,将此时的tempi赋给i,继续向后扫描}//对操作符操作else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='%' || ch == '(' || ch == ')'){int level(char op);//声明level函数if(ch=='(')//如果为(,直接进栈{op.top++;op.data[op.top]=ch;//进栈操作}else if(ch==')'){//如果为),一直出栈直到遇到(while(level(op.data[op.top])!=-1)//若栈顶元素不为(,进入while循环{exp[j]=op.data[op.top];//操作符出栈,存入exp数组中op.top--;j++;if(op.top==-1)break;//如果栈为空,跳出循环}op.top--;//左括号pop出来}else if(op.top==-1)//如果栈为空,直接进栈{op.top++;op.data[op.top]=ch;//进栈操作}//如果所扫描的操作符优先等级比栈顶元素高,直接进栈else if(level(ch)>level(op.data[op.top])){op.top++;op.data[op.top]=ch;//进栈操作}else{//如果所扫描的操作符优先等级没有栈顶元素高,//一直出栈直到比栈顶元素优先级高while(level(ch)<=level(op.data[op.top])){exp[j]=op.data[op.top];//出栈存入exp数组中op.top--;j++;if(op.top==-1)break;//如果栈为空,跳出循环}op.top++;op.data[op.top]=ch;//比栈顶元素优先级高,入栈}i++;//str下标加1,向后扫描}}while(op.top!=-1)//扫描结束后如果操作符栈不为空,出栈直至为空{exp[j]=op.data[op.top];//出栈存入exp数组中op.top--;j++;}exp[j]='\0';//赋\0结束exp字符数组}int level(char op)//判断操作符优先等级{if(op == '+' || op == '-')//若为+、-,等级为1return 1;else if(op == '*' || op == '/' || op == '%')return 2; //若为*、/、%,等级为2else if(op == '(')return -1 ; //若为(,等级为-1elsereturn -3; //其他等级为-3;}double calvalue(double od1,double od2,char tempop)//计算{switch(tempop){case '+':return od1 + od2; //计算加法case '-':return od1 - od2;//计算减法case '*':return od1 * od2;//计算乘法case '/':return od1 / od2;//计算除法case '%':return fmod(od1,od2);//求余}return 0;}double calculate(char exp[])//计算后缀表达式{struct //用结构体创建值栈{double data[MAXSIZE]; //存储数值int top;}od;double d; //声明d变量存储数值double od1,od2; //存储值栈依次pop出来的操作数char ch;char tempch[20]; //声明临时数组存储子串int j=0,t;int length=strlen(exp);//计算exp数组的长度od.top=-1; //初始化值栈,令下标为-1while(j<length){ch=exp[j];//提取exp中第j个元素if(ch!='+' && ch!='-' && ch!= '*' && ch!='/' && ch!='%'){//如果为数字或小数点t=0;while((ch>='0' && ch<='9') ||ch=='.'){tempch[t]=ch;t++;//依次存放到临时数组中j++;ch=exp[j];}tempch[t]='\0';//结束tempch数组d=atof(tempch);//将子串转化成double类型的数od.top++;od.data[od.top]=d;//入值栈}else //若为操作符,从值栈中pop出两个数计算{od2=od.data[od.top];od.top--;//先出栈的赋给od2od1=od.data[od.top]; //后出栈的赋给od1od.data[od.top]=calvalue(od1,od2,ch); //计算出结果后再入栈}j++;}return od.data[od.top];//将结束后值栈中的数pop出来,即为计算结果}main(){char str[MAXSIZE],exps[MAXSIZE]; //定义两个数组printf("请输入算术表达式:\n");gets(str); //从控制台输入算数表达式printf("表达式为:%s\n",str);trans(str,exps); //调用trans函数,得到后缀表达式printf("后缀表达式:%s\n",exps);printf("结果为:%lf\n", calculate(exps)); //调用calculate函数,计算结果}下面给出的是用两个栈算法实现的程序的源代码:#include<stdio.h>#include<string.h>#include<math.h>#include<stdlib.h>#define MAXSIZE 100 //定义宏,数组最大长度为100double calculate(char str[]){struct //用结构体创建操作符栈{char data[MAXSIZE];//用来存放操作符}op;struct //用结构体创建值栈{double data[MAXSIZE];//用来存放操作数int top;}od;char ch;char tempch[20];//声明临时数组存储子串int j=0,t;double d;double od1,od2;//存储值栈依次pop出来的操作数char tempop;int length=strlen(str);//计算str数组的长度op.top=-1;//初始化操作符栈,令下标为-1od.top=-1;//初始化值栈while(j<length){ch=str[j];if((ch>='0' && ch<='9') ||ch=='.')//若为数值或小数点{d=0;t=0;while((ch>='0' && ch<='9') ||ch=='.')//截取子串{tempch[t]=ch;t++;//赋值给临时数组j++;ch=str[j];}tempch[t]='\0';d=atof(tempch);//将子串转化成double类型的数od.top++;od.data[od.top]=d;//入值栈}//对操作符操作else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='%' || ch == '(' || ch == ')') {if(ch=='(')//如果为(,直接进栈{op.top++;op.data[op.top]=ch;//进栈操作}else if(ch==')')//如果为),一直出栈直到遇到({int level(char op);//声明level函数while(level(op.data[op.top])!=-1)//若栈顶元素不为(,进入while循环{//声明calvalue函数double calvalue(double od1,double od2,char tempop);od2=od.data[od.top];od.top--;od1=od.data[od.top];tempop=op.data[op.top];op.top--;od.data[od.top]=calvalue(od1,od2,tempop);//计算出结果后入值栈if(op.top==-1)break;//如果操作符栈为空,跳出循环}op.top--;//左括号pop出来}else if(op.top==-1)//如果栈为空,直接进栈{op.top++;op.data[op.top]=ch;//进栈操作}//如果所扫描的操作符优先等级比栈顶元素高,直接进栈else if(level(ch)>level(op.data[op.top])){op.top++;op.data[op.top]=ch;//进栈操作}else{//如果所扫描的操作符优先等级没有栈顶元素高,//一直出栈直到比栈顶元素优先级高while(level(ch)<=level(op.data[op.top])){od2=od.data[od.top];od.top--;od1=od.data[od.top];tempop=op.data[op.top];op.top--;od.data[od.top]=calvalue(od1,od2,tempop);//计算结果后入值栈if(op.top==-1)break;//如果栈为空,跳出循环}op.top++;op.data[op.top]=ch;//比栈顶元素优先级高,入操作符栈}j++;//str下标加1,向后扫描}}while(op.top!=-1)//扫描结束后如果操作符栈不为空,出栈直至为空{od2=od.data[od.top];od.top--;od1=od.data[od.top];tempop=op.data[op.top];op.top--;od.data[od.top]=calvalue(od1,od2,tempop);//计算结果后入值栈}return od.data[od.top];//将结束后值栈中的数pop出来,即为计算结果}int level(char op)//判断操作符优先等级{if(op == '+' || op == '-')//若为+、-,等级为1return 1;else if(op == '*' || op == '/' || op == '%')return 2; //若为*、/、%,等级为2else if(op == '(')return -1 ; //若为(,等级为-1elsereturn -3; //其他等级为-3;}double calvalue(double od1,double od2,char tempop)//计算{switch(tempop){case '+':return od1 + od2;//计算加法case '-':return od1 - od2;//计算减法case '*':return od1 * od2;//计算乘法case '/':return od1 / od2;//计算除法case '%':return fmod(od1,od2);//求余}return 0;}void main(){char str[MAXSIZE];//定义str数组存放数学表达式printf("输入算术表达式:\n");gets(str); //从控制台输入算数表达式printf("结果是:%lf\n",calculate(str));//调用calculate函数,计算结果}四、运行结果图6 中缀转后缀算法运行结果图7 两个栈算法运行结果五、遇到的问题及解决编程的前期工作很重要,需要明确的理清思路,而编写运行的过程中更是会出现很多问题,有因粗心造成的拼写错误,有语法错误,也有逻辑错误。