将中缀表达式转换为后缀表达式并计算
中缀表达式转换为后缀表达式

中缀表达式转换为后缀表达式课程设计任务:中缀表达式转后缀表达式,并求值。
课程设计思路:把中缀表达式转换为后缀表达式算法的基本思路是从头到尾地扫描中缀表达式中的每个字符,对于不同类型的字符按不情况进行处理。
若遇到的是空格则认为是分隔符,不需要进行处理;若遇到的是数字或小数点,则直接写入到c2中;若遇到的是左括号,则应把它压入到运算符栈中,待以它开始的括号内的表达式转换完毕后再出栈;若遇到的是右括号,则表明括号内的中缀表达式已经扫描完毕,把从栈底直到保存着的对应左括号之间的运算符依次退栈并写入c2串中;若遇到的是运算符,当该运算符的优先级大于栈顶运算符的优先级(加减运算符的优先级设定为1,乘除运算符的优先级设定为2,在栈中保存的特殊运算符’(’的优先级设定为0)时,表明该运算符的后一个运算对象还没有被扫描并放入到c2串中,应把它暂存于运算符栈中,待它的后一个运算对象从c1串中读出并写入到c2串中后,再另其出栈并写入c2串中;若遇到的运算符的优先级小于等于栈顶运算符的优先级,这表明栈顶运算符的两个运算对象已经被保存到c2串中,应将栈顶运算符退栈并写入到c2串中,对于新的栈顶运算符仍继续进行比较和处理,直到被处理的运算符的优先级大于栈顶运算符的优先级为止,然后另该运算符进栈即可。
按照以上过程扫描到中缀表达式结束符时,把栈中剩余的运算符依次退栈并写入到后缀表达式中,再向c2写入表达式结束符和字符串结束符’\0’,整个转换过程就处理完毕,在c2中就得到了转换成的后缀表达式。
课程设计流程:设中缀算术表达式为:10+(18+9*3)/15-6,则转换过程如下:(1)开始时存放后缀表达式的字符串c2为空:(2)当扫描到左括号时,c2和栈中的数据变化如下:1 0((3)当扫描到数值3时,c2和栈中的数据变化为:1 0 1 8 9 3( + *(4)当扫描到右括号时,c2和栈变为:1 0 1 8 9 3 * +(5)当扫描到的数值15时,c2和栈又变为:1 0 1 8 9 3 * + 1 5/(6)当扫描到‘’字符时,c2和栈为:1 0 1 8 9 3 * + 1 5 / + 6-7)当整个处理过程结束后,栈为空,c2为:1 0 1 8 9 3 * + 1 5 / + 6 -算法基本思想:从头到尾扫描中缀表达式,对不同类型的字符按不同情况处理;1、如果是数字则直接放入后缀表达式数组;2、如果是左括号则直接入栈;3、如果是右括号,则把从栈顶直到对应左括号之间的运算符依次退栈,并清除对应的左括号;4、对于运算符,如果该运算符的优先级大于栈顶优先级,则直接入栈,若该运算符的优先级小于等于栈顶优先级,则先把栈顶运算符出栈,写入后缀表达式数组,然后再入栈;5、扫描完成后,取出栈中所有运算符,写入后缀表达式数组。
中缀转后缀表达式计算报告

目录一、设计思想 (01)二、算法流程图 (02)三、源代码 (04)四、运行结果 (14)五、遇到的问题及解决 (16)六、心得体会 (16)一、设计思想(1)中缀表达式转后缀表达式并计算创建一个数组存储输入的计算表达式。
另创建一个数组储存将要生成的后缀表达式。
创建一个栈储存操作符。
对已存储的表达式数组扫描。
判断当前节点,如果是操作数或’.’,直接加入后缀表达式中,如果是操作符,则比较前一个操作符与当前操作符的优先级。
如果前一个操作符的优先级较高,则将前一个操作符加入后缀表达式中,否则将操作符压入操作符栈。
如果遇到左括号’(’,直接入栈;如果遇到右括号’)’,则在操作符栈中反向搜索,直到遇到匹配的左括号为止,将中间的操作符依次加到后缀表达式中。
当执行完以上操作,发现栈中仍有剩余操作符,则将操作符依次加到后缀表达式中。
此时中缀表达式已经转换成了后缀表达式。
对后缀表达式进行计算。
如果后缀表达式为大于0小于9的字符,则将它转换成浮点型数据并存入数栈中。
如果遇到操作符,则从数栈中提取两个数,进行相应的运算。
依次进行下去,当没有运算符是,运算结束得到最后的结果。
(2)直接表达式求值创建一个数组存储输入的计算表达式。
创建两个栈,一个字符型的栈,一个双精度型的栈。
分别用来存储字符和数。
对已存储的表达式数组扫描。
判断当前节点,如果是操作数和’.’,将字符型的操作数转换为浮点型的数后存入操作数栈。
如果是操作符则判断操作符的优先级。
如果字符栈中已存储符号的优先级小于要存入的字符的优先级,则直接让字符入操作符栈。
如果字符栈中已存储符号的优先级大于或等于要存入的字符的优先级,则取出操作符栈中的一个字符和操作数栈中的两个数进行计算,然后将结果存入操作数栈中,同上进行下去,直到字符栈中已存储符号的优先级小于要存入的字符的优先级时,将操作符存入操作符栈中。
当遇到左括号’(’,将左括号直接存入操作符栈中。
当遇到右括号’)’,则在操作符栈中反向搜索,并且每搜到一个字符就在操作数栈中取两个数进行相应的计算。
逻辑表达式短路求值后缀表达式

逻辑表达式短路求值后缀表达式逻辑表达式短路求值后缀表达式的过程如下:1. 将中缀逻辑表达式转换为后缀表达式。
这个过程可以使用运算符优先级和括号来确定运算符的顺序。
2. 执行后缀表达式的求值过程。
从左到右扫描后缀表达式:- 如果遇到操作数,将其压入栈中。
- 如果遇到操作符,从栈中弹出相应数量的操作数进行运算,并将运算结果压入栈中。
- 重复上述步骤,直到扫描完后缀表达式。
3. 最终栈中剩下的元素就是整个逻辑表达式的求值结果。
例如,对于逻辑表达式 "A && B || C",其后缀表达式为 "A B&& C ||"。
假设 A = true,B = false,C = true,那么短路求值的过程如下:1. 将 A 和 B 压入栈中。
2. 遇到 "&&" 操作符,从栈中弹出 B(false),然后从栈中弹出 A(true)。
将 A && B 的结果(false)压入栈中。
3. 将 C 压入栈中。
4. 遇到 "||" 操作符,从栈中弹出 C(true),然后从栈中弹出A &&B 的结果(false)。
将 (A && B) ||C 的结果(true)压入栈中。
5. 栈中剩下的元素是最终的结果,即 (A && B) || C 的值为 true。
因此,逻辑表达式 "A && B || C" 的短路求值后缀表达式的结果为 true。
中缀转后缀并输出运算步骤

中缀转后缀并输出运算步骤从中缀表达式转换为后缀表达式的过程中,需要遵循一定的规则和算法。
下面将具体介绍中缀转后缀的步骤及其运算过程。
一、引言中缀表达式是我们日常生活中最常见的表达式形式,例如:2 + 3 * 4。
但是,对于计算机来说,中缀表达式并不方便进行计算,因此需要将其转换为后缀表达式。
后缀表达式也被称为逆波兰表达式,它的计算规则更加简单明了。
二、中缀转后缀的规则和算法1. 创建一个空的栈,用于存储运算符。
2. 从左到右遍历中缀表达式的每个元素。
3. 如果当前元素是操作数,则直接输出到后缀表达式。
4. 如果当前元素是左括号"(",则将其压入栈中。
5. 如果当前元素是右括号")",则将栈中的运算符依次弹出并输出到后缀表达式,直到遇到左括号为止。
注意:左括号不输出。
6. 如果当前元素是运算符,则判断栈顶运算符的优先级:- 若栈为空,则直接将当前运算符压入栈中。
- 若栈不为空,且当前运算符的优先级小于等于栈顶运算符的优先级,则将栈顶运算符弹出并输出到后缀表达式,直到栈为空或者栈顶运算符的优先级小于当前运算符。
- 将当前运算符压入栈中。
7. 遍历完中缀表达式后,如果栈中还有运算符,则依次弹出并输出到后缀表达式。
三、运算过程示例考虑中缀表达式:"2 + 3 * 4 - (5 + 6) / 7"1. 创建空栈和空后缀表达式。
2. 从左到右遍历中缀表达式的每个元素:- 遇到"2",为操作数,直接输出到后缀表达式。
- 遇到"+",为运算符,将其压入栈中。
- 遇到"3",为操作数,直接输出到后缀表达式。
- 遇到"*",为运算符,将其压入栈中。
- 遇到"4",为操作数,直接输出到后缀表达式。
- 遇到"-",为运算符,栈顶为"*",优先级高于"-",因此将"*"弹出并输出到后缀表达式,然后将"-"压入栈中。
中缀表达式得到后缀表达式(c++、python实现)

中缀表达式得到后缀表达式(c++、python实现)将中缀表达式转换为后缀表达式的算法思想如下: 从左往右开始扫描中缀表达式 遇到数字加⼊到后缀表达式 遇到运算符时: 1、若为‘(’,⼊栈 2、若为’)‘,把栈中的运算符依次加⼊后缀表达式,直到出现'(',’(‘出栈,退出该次循环 3、若除’(‘ 和 ‘)’,要⼊栈的运算符优先级⼤于等于栈顶的运算符的优先级,直接⼊栈,否者,栈顶运算符出栈,再次⽐较,直到出现优先级低的运算符,或者栈为空,退出 中缀表达式为空时,若栈不为空,栈中元素⼀直出栈,直到栈为空运算符 ( *,/ +,- )栈内优先级 1 5 3 6栈外优先级 6 4 2 1C++实现如下:#include <iostream>#include <algorithm>#include <string>#include <stack>#include <map>using namespace std;int main(){string s_mid="a+b-a*((c+d)/e-f)+g";string s_beh="";stack<char> stk;// stack<char> stk1;map<char,int> op;//利⽤map来实现运算符对应其优先级op['(']=0;op[')']=0;op['+']=1;op['-']=1;op['*']=2;op['/']=2;string::iterator it=s_mid.begin();;while(it!=s_mid.end()){if(op.count(*it))//判断该元素是否为运算符{if(*it==')')//情况2{while(stk.top()!='('){s_beh+=stk.top();stk.pop();}stk.pop();}else if(stk.empty()||*it=='('||op[*it]>op[stk.top()])//情况1、情况3{stk.push(*it);}else if(op[*it]<=op[stk.top()])//情况3{while(op[*it]<=op[stk.top()]&&(!stk.empty())){s_beh+=stk.top();stk.pop();if(stk.empty()) break;}stk.push(*it);}}else{s_beh+=*it;}it++;// cout<<s_beh<<'\t'; 输出每次结构// stk1=stk;// while(!stk1.empty()) 输出栈内情况// {// cout<<stk1.top();// stk1.pop();// }// cout<<endl;if(it==s_mid.end())//当中缀表达式输出完成,所有元素出栈 {while(!stk.empty()){s_beh+=stk.top();stk.pop();}break;}}cout<<s_beh<<endl;return0;}View Codepython实现如下:#-*- coding:utf-8 -*-if__name__=='__main__':s_mid='23/b+(c*d-e*f)/g's_beh=''d={'(':0,')':0,'+':1,'-':1,'*':2,'/':2};l=[]while(len(s_mid)):if s_mid[0] in d.keys():if s_mid[0]==')':while True:if l[len(l)-1]=='(':breakelse:s_beh+=l.pop()l.pop()elif len(l)==0 or s_mid[0]=='('or d[l[len(l)-1]]<d[s_mid[0]]: l.append(s_mid[0])elif d[l[len(l)-1]]>=d[s_mid[0]]:while d[l[len(l) - 1]] >= d[s_mid[0]]:s_beh+=l.pop()if len(l)==0:breakl.append(s_mid[0])else:s_beh+=s_mid[0]s_mid=s_mid[1:]if len(s_mid)==0:while len(l):s_beh += l.pop()print s_behView Code。
算法笔记--中缀表达式转后缀表达式后缀表达式计算

算法笔记--中缀表达式转后缀表达式后缀表达式计算中缀表达式转后缀表达式规则中缀表达式a + b*c + (d * e + f) * g,转换成后缀表达式则为a b c * + d e * f + g * +转换过程需要⽤到栈,具体过程如下:1 如果遇到操作数,我们就直接将其输出。
2 如果遇到操作符,则我们将其放⼊到栈中,遇到左括号时我们也将其放⼊栈中。
3 如果遇到⼀个右括号,则将栈元素弹出,将弹出的操作符输出直到遇到左括号为⽌。
注意,左括号只弹出并不输出。
4 如果遇到任何其他的操作符,如+, *, (等,从栈中弹出元素直到遇到发现更低优先级的元素(或者栈为空)为⽌。
弹出完这些元素后,才将遇到的操作符压⼊到栈中。
有⼀点需要注意,只有在遇到 )的情况下我们才弹出( ,其他情况我们都不会弹出( 。
即:若操作符op的优先级⾼于栈顶操作符的优先级,则压⼊操作符栈若操作符op的优先级⼩于等于栈顶操作符的优先级,则将操作栈的操作符不断弹出到后缀表达式中,直到op的优先级⾼于栈顶操作符的优先级5 如果我们读到了输⼊的末尾,则将栈中所有元素依次弹出。
实例a +b *c + (d *e + f) * g1. ⾸先读到a,直接输出。
2. 读到“+”,将其放⼊到栈中。
3. 读到b,直接输出。
此时栈和输出的情况如下:4. 读到“*”,因为栈顶元素"+"优先级⽐" * " 低,所以将" * "直接压⼊栈中。
5. 读到c,直接输出。
此时栈和输出情况如下:6. 读到" + ",因为栈顶元素" * "的优先级⽐它⾼,所以弹出" * "并输出,同理,栈中下⼀个元素" + "优先级与读到的操作符" + "⼀样,所以也要弹出并输出。
然后再将读到的" + "压⼊栈中。
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.遇到操作数:直接输入到后缀表达式栈2.遇到运算符,直接入操作符栈3.遇到左括号:直接将其入栈4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。
5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈6.最终将操作符栈中的元素依次出栈,输出到后缀表达式栈。
以下是自己写的代码。
亲测没有问题。
(模拟一个计算器,可以带括号,中间可以空格,只支持整数输入,但是输出结果精确到小数后6位)#include "stdio.h"#define MAX_LEN 100typedef struct cal{unsigned char isOper;//是否是操作数1,操作符0.操作数double Num; //值。
或者是操作符的ASCII值}STRUCT_CAL;#define IS_NUM 0x00#define IS_OPER 0x01STRUCT_CAL stackCal[MAX_LEN];STRUCT_CAL stackCalBack[MAX_LEN];unsigned char topCal;char stackOper[MAX_LEN];unsigned char topOper;/****************************************************************** 堆栈初始化*****************************************************************/void stackInit(void){int i;for(i=0;i<MAX_LEN;i++){stackCal[i].isOper = 0;stackCal[i].Num = 0;stackOper[i] = 0;}topCal = topOper = 0;}/***************************************************************** * 返回堆栈的栈顶,返回后栈顶减一*****************************************************************/ STRUCT_CAL * stackCalPop(void){if(topCal == 0)return (STRUCT_CAL *)0;return stackCal+(--topCal);}/***************************************************************** * 计算表达式入栈*****************************************************************/void stackCalPush(double num, unsigned char isOper){if(topCal>=MAX_LEN)return;stackCal[topCal].Num = num;stackCal[topCal].isOper= isOper;topCal++;}/***************************************************************** * 操作符出栈*****************************************************************/char stackOperPop(void){if(topOper == 0)return 0;return stackOper[--topOper];}/****************************************************************** 操作符入栈*****************************************************************/void stackOperPush(char oper){if(topOper >=MAX_LEN)return;stackOper[topOper++] = oper;}/****************************************************************** 比较两个sour sour1 的优先级* 1 sour >= sour1 直接入操作符栈* 0 sour < sour1 直接入计算表达式栈*****************************************************************/ unsigned char comparPrior(char sour, char sour1){if(sour =='\0' ||sour1 == '\0') return 1;switch(sour){case '+':case '-':if(sour1 == '*' ||sour1 == '/'||sour1 == '+' ||sour1 == '-' ){return 0;}else{return 1;}break;case '*':case '/':if(sour1 == '*' ||sour1 == '/'||sour1 == '+' ||sour1 == '-'||sour1 == '('){return 1;}else{return 0;}break;default:return 1;break;}}/****************************************************************** 将输入的字符串转换为栈*****************************************************************/void StrToCal(char *pStr){int tmpNum = 0;char tmpOper;char islastNum = 0;//判断上一个字符是什么。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》实验报告◎实验题目:使用键盘输入表达式,计算表达式的值并输出;将表达式转化成后缀表达式输出,利用后缀表达式求表达式的值并输出。
◎实验目的:使用栈的操作编写关于数据结构的程序。
◎实验内容:写出程序并上机调试、通过。
一、需求分析1、演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“请输入表达式”时输入中缀表达式。
然后计算机终端输出转换后的后缀表达式及计算后的结果。
2、程序执行的命令包括:(1)构造链栈;(2)输入数据;(3)判断输入的表达式是否为非法表达式;(4)将中缀表达式转换为后缀表达式;(5)计算表达式的值;(6)输出。
(7)结束4、本程序能将中缀表达式转换为后缀表达式,并且能计算表达式的值。
5、输入及输出示例:例1:请输入表达式6+3*(6+5)后缀表达式:6 3 6 5 + * +计算结果为:39Press any key to continue例2:请输入表达式6-3*(7+1ERROR:表达式错误Press any key to continue二概要设计1.基本操作(1)、struct node操作结果:创建结构体(2)、int Searchexpression(char string1[])初始条件:表达式string1已经存在。
操作结果:判断表达式是否非法(3)、struct node *Initialization()操作结果:创建栈链。
(4)、struct node *assort(struct node *s)初始条件:string1、string2已存在。
操作结果:将中缀表达式转换为后缀表达式并存在string2中。
(5)、struct node *calcolate(struct node *s)操作结果:求出表达式的值2、模块调用图三详细设计1、每个模块:(1) 定义结构体struct node{char data;int num;struct node *next;};(2) 判断表达式是否非法int Searchexpression(char string1[]){int i1,b1,b2;int m;m=strlen(string1);if(string1[0]<'0'||string1[0]>'9'){printf("ERROR:表达式缺操作数!\n");return(WRONG);}for(i1=0;i1<=m;i1++){if(string1[i1]=='(')b1++;elseif(string1[i1]==')')b2++;}if(b1!=b2){printf("ERROR:缺少括号\n");return(WRONG);}for(i1=0;i1<m;i1++)if('0'<=string1[i1]&&string1[i1]<='9'&&'0'<=string1[i1+1]&&str ing1[i1+1]<='9'){ printf("ERROR:表达式缺操作符!\n");return(WRONG);}for(i1=0;i1<=m;i1++)if(string1[i1]=='+'&&(string1[i1+1]=='+'||string1[i1+1]=='-'|| string1[i1+1]=='*'||string1[i1+1]=='/')){ printf("ERROR:表达式缺操作数!\n");return(WRONG);}elseif(string1[i1]=='-'&&(string1[i1+1]=='+'||string1[i1+1]=='-'|| string1[i1+1]=='*'||string1[i1+1]=='/')){ printf("ERROR:表达式缺操作数!\n");return(WRONG);}elseif(string1[i1]=='*'&&(string1[i1+1]=='+'||string1[i1+1]=='-'|| string1[i1+1]=='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数!\n");return(WRONG);}elseif(string1[i1]=='/'&&(string1[i1+1]=='+'||string1[i1+1]=='-'|| string1[i1+1]=='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数!\n");return(WRONG);}return(RIGHT);}(3)、将中缀表达式转换为后缀表达式struct node *assort(struct node *s)//输入字符串{struct node *p,*top;int i;top=s;int m;char a;m=strlen(string1);for(i=0;i<=m;i++){a=string1[i];if('0'<=string1[i]&&string1[i]<='9'){string2[j]=string1[i];j++;}else{switch(a){case '(':{p=(struct node *)malloc(sizeof(struct node));p->data=a;p->next=top;top=p;break;}case '*':case '/':string2[j]=' ';j++;if((top->data=='*')||(top->data=='/')){string2[j]=top->data;j++; //比其高,现将栈顶运算符出栈,再进栈。
top->data=a;break;}else{p=(struct node *)malloc(sizeof(struct node));//否,直接进栈p->data=a;p->next=top;top=p;break;}case '+':case '-':{string2[j]=' ';j++;if(top->data=='+'||top->data=='-'||top->data=='*'||top->data== '/'){string2[j]=top->data;j++;top->data=a;break;}else{p=(struct node *)malloc(sizeof(struct node));p->data=a;p->next=top;top=p;break;}}case ')':{string2[j]=' ';j++;if(top->data=='@'){printf("input error");break;}while(top->data!='('){string2[j]=top->data;j++;p=top;top=top->next;free(p);}p=top;top=top->next;free(p);break;}}}}while(top->data!='@'){string2[j]=top->data;j++;p=top;top=top->next;free(p);}string2[j]='#';printf("后缀表达式为:");for(i=0;i<j;i++)if(string2[i]!=' ')printf("%c ",string2[i]);printf("\n ");return top;}(4)表达式求值struct node *calcolate(struct node *s){struct node *top,*p;char *q;int x,y,a;int i,n;top=s;//指向栈顶的指针for(i=0;i<=j;i++)//遍历字符串string2{if(string2[i]>='0'&&string2[i]<='9'){q=&string2[i];a=atoi(q);for(n=i;string2[n]>='0'&&string2[n]<='9';n++){} p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;i=n-1;}elseif(string2[i]=='#') //遇#号结束标志,输出栈中的最后计算结果printf("计算结果为:%d\n",top->num);else{if(string2[i]==' '){}else{y=top->num;p=top;top=top->next;free(p);x=top->num;p=top;top=top->next;free(p);switch(string2[i]){case '+':{a=x+y;p=(struct node *)malloc(sizeof(struct node));p->num=a;p->next=top;top=p;break;}case '-':{a=x-y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}case '*':{a=x*y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}case '/':{if(y==0)printf("ERROR:除数为零!\n");a=(float)x/y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}}}}}return 0;}(5)、主函数void main(){struct node *top,*head;top=Initialization();//建立一个链栈,并返回栈顶指针printf("请输入表达式:\n");gets(string1);if(Searchexpression(string1)){head=assort(top);//中缀转化为后缀表达式calcolate(head);}}2、完整函数#include<stdio.h>#include<malloc.h>#include<string.h>#include<stdlib.h>#define MAX 60#define RIGHT 1#define WRONG 0#define DEMAX 15#define NULL 0char string1[MAX];char string2[MAX];int j=0;struct node //定义结构体。