中缀表达式转换为后缀表达式
中缀转后缀表达式
中缀转后缀表达式中缀表达式是我们平时最常见的表达式形式，例如：1 + 2 * 3。
但是在计算机中，我们更常使用后缀表达式来进行计算。
因此，将中缀表达式转换为后缀表达式是非常重要的。
一、中缀表达式中缀表达式是指运算符位于两个操作数之间的表达式。
例如：1 + 2 * 3。
在中缀表达式中，运算符的优先级是由括号来确定的。
括号内的表达式优先计算，同级别的运算符按照从左到右的顺序计算。
二、后缀表达式后缀表达式是指运算符位于两个操作数之后的表达式。
例如：1 2 3 * +。
在后缀表达式中，运算符的优先级是由运算符本身来确定的。
同级别的运算符按照从左到右的顺序计算。
三、中缀转后缀中缀表达式转换为后缀表达式的过程可以使用栈来实现。
具体步骤如下：1. 初始化两个栈：运算符栈和结果栈。
2. 从左到右扫描中缀表达式。
3. 如果遇到操作数，直接将其压入结果栈。
4. 如果遇到运算符，比较其与运算符栈栈顶的优先级。
5. 如果运算符栈为空，或栈顶运算符为左括号“（”，则直接将此运算符入栈。
6. 否则，若优先级比栈顶运算符的优先级高或相等，也将运算符压入运算符栈。
7. 否则，将运算符栈顶的运算符弹出并压入结果栈中，再次转到步骤4与新的栈顶运算符比较。
8. 如果遇到括号，如果是左括号“（”，则直接压入运算符栈；如果是右括号“）”，则依次弹出运算符栈顶的运算符，并压入结果栈中，直到遇到左括号为止，此时将这一对括号丢弃。
9. 重复步骤2至8，直到表达式的最右边。
10. 将运算符栈中剩余的运算符依次弹出并压入结果栈中。
11. 最后将结果栈中的元素依次弹出，即可得到后缀表达式。
四、总结中缀表达式转换为后缀表达式是一个非常重要的算法，它可以使我们更方便地进行计算。
在实际应用中，我们可以使用栈来实现这个算法。
通过这个算法的学习，我们可以更深入地理解计算机中的表达式计算过程。
中缀转后缀表达式算法
中缀转后缀表达式算法
中缀表达式转后缀表达式（也称为逆波兰表达式）是一种将中缀表达式转换为后缀表达式的算法。
它的基本思想是将中缀表达式转换为一个后缀表达式，其中操作符位于操作数之后，而不是操作数之前。
中缀表达式转后缀表达式的算法步骤如下：
1. 从左到右扫描中缀表达式；
2. 如果读取的是操作数，则将其压入堆栈；
3. 如果读取的是运算符，则比较其与栈顶运算符的优先级：
（1）如果栈顶运算符的优先级高于或等于读取的运算符，则将栈顶运算符弹出，并将其压入输出队列；
（2）如果栈顶运算符的优先级低于读取的运算符，则将读取的运算符压入堆栈；
4. 重复步骤2和3，直到表达式末尾；
5. 将栈中所有元素依次弹出，压入输出队列，完成中缀表达式到后缀表达式的转换。
中缀表达式转后缀表达式算法的优点是它可以有效地将中缀表达式转换为后缀表达式，从而简化表达式的计算过程。
它的缺点是它需要记住操作符的优先级，并且需要使用堆栈来存储操作符，这可能会增加算法的复杂度。
总之，中缀表达式转后缀表达式算法是一种有效的算法，它可以有效地将中缀表达式转换为后缀表达式，从而简化表达式的计算过程。
将中缀表达式转换成后缀表达式的三种方法
将中缀表达式转换成后缀表达式的三种方法中缀表达式是我们平常最常见的表达式形式，但在计算机的运算过程中，我们常常需要将中缀表达式转换成后缀表达式，因为后缀表达式具有易于计算的特点。
那么，接下来我们将介绍三种将中缀表达式转换成后缀表达式的方法。
一、栈的方法这种方法是最常见的一种方法，也是比较易理解的一种方法。
我们可以借助栈来完成中缀表达式转换成后缀表达式的过程。
具体的操作如下：1. 声明一个操作符的栈stack（栈中存放操作符）和一个后缀表达式的列表res（列表中存放转换后的后缀表达式）。
2. 从左到右遍历中缀表达式。
3. 若当前字符为数字，则直接将该数字添加到res中。
4. 若当前字符为左括号“（”，则将其压入stack栈中。
5. 若当前字符为右括号“）”，则依次弹出stack栈中的操作符并加入到res中，直到遇到左括号为止。
6. 若当前字符为操作符，那么则需判断当前操作符与stack栈顶操作符的优先级，若当前操作符的优先级小于等于栈顶操作符，则弹出栈顶操作符并加入到res中，重复此步骤，直到当前操作符大于栈顶操作符优先级，最后将当前操作符压入stack栈。
7. 当遍历完整个中缀表达式后，若stack栈中还有剩余操作符，则依次弹出栈顶操作符并加入到res中。
8. 最终，res中的表达式就是转换后的后缀表达式。
二、递归调用方法这种方法是使用递归的方式来完成。
具体的操作如下：1. 若当前遍历的字符为数字，则直接输出该数字。
2. 若当前遍历的字符为左括号“（”，则递归读取该括号内的表达式。
3. 若当前遍历的字符为右括号“）”，则返回。
4. 若当前遍历的字符为操作符，“x”，“/”，“+”，“-”，则递归调用该表达式右边的操作符，比如“x”，“/”，然后再递归调用左边的操作符，比如“+”，“-”，然后输出左操作数和右操作数，最后输出当前操作符。
5. 最终，输出的表达式即为转换后的后缀表达式。
三、判断法这种方法也是比较常见的一种方法。
数据结构中缀表达式改后缀表达式
程序从标准输入读入一行字符串，是一个合法的后缀表达式，数字和运 算符之间
由空格分隔。数字可以是带小数部分的浮点数。
输出形式： 向标准输出打印结果，输出只有一行，是转换后的中缀表达式。 并且 ： 1、各分量（包括括号）紧密输出，不使用空格进行分隔； 2、在转换后的各运算数的出现顺序不变； 3、浮点数保留输入时的小数位数。
Node p,q,f;
//连接两个链表
if(flag==0) {
printf("错误\n"); exit(0); }
E->Lists[flag-1]->c=ch;
p=E->Lists[flag-1]; f=E->Lists[flag]->next;
while(p->next!=NULL) p=p->next;
*/
#include<stdio.h> #include<stdlib.h>
struct Expression; typedef struct Expression *Node;
struct Expressionlist; typedef struct Expressionlist *Elist;
struct Expression {
7. 之后是符号“+”，此时当前栈顶元素比这个“+”的优先级高，因此栈中元素出 栈并输出（没有比“+”号更低的优先级，所以全部出栈），总输出表达式为 9 3 1 - 3 * +.然后将当前这个符号“+”进栈。也就是说，前 6 张图的栈底的“+”是指中缀 表达式中开头的 9 后面那个“+”，而下图中的栈底（也是栈顶）的“+”是指 “9+(3-1)*3+”中的最后一个“+”。 8. 紧接着数字 10，输出，总表达式变为 9 3 1-3 * + 10。
中缀表达式转后缀表达式---栈--二叉树---四则运算
中缀表达式转后缀表达式---栈--⼆叉树---四则运算 我们平常书写的四则运算表达式属于中缀表达式，形式为"9+（3-1）*3+10/2"，因为所有的运算符号都在两操作数之间，所以称为中缀表达式。
我们使⽤中缀表达式来计算表达式的值，不过这种形式并不适合计算机求解。
接下来，我们将中缀表达式转化为后缀表达式，所谓的后缀表达式就是操作符位于操作数后⾯的不包含括号的算数表达式，也叫做逆波兰表达式。
1）⾸先介绍⼀种⼈⼯的转化⽅法()。
以"9+（3-1）*3+10/2"为例，按照运算的规则，找出⾸先计算的部分，这部分包含两个操作数和⼀个操作符，将操作符移动到两个操作数右侧，这就完成了第⼀部分的转换，将这部分看作⼀个操作数，按照运算规则，以相同的⽅法转换，转换过程如下：2）还可以利⽤⼆叉树求得后缀表达式，⾸先利⽤中缀表达式构造⼆叉树，数字是叶⼦节点，操作符为根节点。
每次找到“最后计算”的运算符，作为当前根节点，运算符左侧表达式作为左节点，右侧表达式作为右节点，然后递归处理()。
9+（3-1）*3+10/2对应的⼆叉树的构造过程如下图所⽰： 此⼆叉树做后序遍历就得到了后缀表达式。
对应代码：3）还可以利⽤栈来实现中缀表达式转化为后缀表达式。
转化⽅法如下所述：a.从左向右扫描表达式，如果是数字就输出，否则转b。
b.如果当前扫描的字符是")"，则栈顶元素出栈并输出⼀直到栈顶元素为"("，然后删除栈顶元素"("，并不输出。
c.如果扫描的字符或者栈顶元素是“(”，扫描的字符直接⼊栈。
即使扫描的字符是")"也不会⼊栈，因为如果是")"，会出栈⾄栈顶元素是"("。
d.如果扫描字符是"+"或者"-",则⼀直出栈⾄栈顶元素为"+"或者"-"或者"("。
算术表达式（中缀表达式）转换为后缀表达式
算术表达式（中缀表达式）转换为后缀表达式将后缀表达式exp转换为postexp的过程如下：while(从exp读取字符ch，ch!='\0'){ 若ch为数字，将后继的数字都⼀次存放到postexp中，并以字符'#'标志数值串的结束； 若ch为左括号“（”，将此括号进栈到运算符栈op中； 若ch为右括号“）”，将运算符栈op依次出栈，直到“（”，并将“（”也出栈； 若ch为运算符，优先级不⼤于运算符op的栈顶运算符（除栈顶运算符为“（”外）的优先级，则依次出栈并存⼊到postexp中，然后将ch 进栈}若中缀表达式exp扫描完毕，将运算符栈op中的所有运算符依次出栈并存放到postexp中，就得到了后缀表达式。
完整代码：#include <stdio.h>#define MAXSIZE 50typedef char elemType;//运算符栈typedef struct{elemType data[MAXSIZE];int top;}OP;OP op;//中缀表达式转为后缀表达式void trans(char exp[],char postexp[]){op.top=-1;int i=0,j=0;char ch=exp[i];while(ch!='\0'){switch(ch){case'(':{op.top++;op.data[op.top] = ch;break;}case')':{while(op.data[op.top]!='('){postexp[j++]=op.data[op.top--];}op.top--; //去除 '('break;}case'+':case'-':{while(op.top!=-1&&op.data[op.top]!='('){postexp[j++]=op.data[op.top--];}op.top++;op.data[op.top]=ch;break;}case'*':case'/':{while(op.top!=-1&&(op.data[op.top]=='*'||op.data[op.top]=='/')){postexp[j++]=op.data[op.top];op.top--;}op.top++;op.data[op.top]=ch;break;}case'':break;default :{while(ch>='0'&&ch<='9'){postexp[j++]=ch;i++;ch=exp[i];}i--; //不是数字退后⼀个，⽤switch来进⾏判断 postexp[j++]='#'; //在数字结束后添加'#'以便区分}}i++;ch=exp[i];}while(op.top!=-1){ //将运算符栈中postexp[j++]=op.data[op.top--];}postexp[j]='\0';}。
中缀表达式转后缀表达式
中缀表达式转后缀表达式逆波兰表达式先说⼀下中缀表达式，平时我们使⽤的运算表达式就是中缀表达式，例如1+3*2，中缀表达式的特点就是：⼆元运算符总是置于与之相关的两个运算对象之间⼈读起来⽐较好理解，但是计算机处理起来就很⿇烦，运算顺序往往因表达式的内容⽽定，不具规律性后缀表达式，后缀表达式的特点就是：每⼀运算符都置于其运算对象之后，以上⾯的中缀表达式1+2*3为例⼦，转为后缀表达式就是123*+下⾯先分析怎么把中缀表达式转换为后缀表达式，这⾥我们考虑六种操作符'+'、'-'、'*'、'/'、'('、')'，完成中缀转后缀我们需要两个数组，都以栈的⽅式来操作，⼀个数组⽤来存放后缀表达式（char num[100]），⼀个数组⽤来临时存放操作数（char opera[100]）（这⾥说临时存放，是因为最后都要⼊栈到后缀表达式数组num中，这个数组就相当于⼀个中转站）1、从左往右扫描中缀表达式（这⾥我们以1*(2+3)为例）2、如果是数字那么将其直接⼊栈到数组num中3、如果是操作数，需要进⼀步判断（1）如果是左括号'('直接⼊栈到数组opera中（2）如果是运算符（'+'、'-'、'*'、'/'），先判断数组opera的栈顶的操作数的优先级（如果是空栈那么直接⼊栈到数组opera），如果是左括号那么直接⼊栈到数组opera中，如果栈顶是运算符，且栈顶运算符的优先级⼤于该运算符那么将栈顶的运算符出栈，并⼊栈到数组num中，重复步骤3，如果栈顶运算符优先级⼩于该运算符，那么直接将该运算符⼊栈到opera中（3）如果是右括号')'，那么说明在opera数组中⼀定有⼀个左括号与之对应（在你没输错的情况下），那么将opera中的运算符依次出栈，并⼊栈到num中，直到遇到左括号'('（注意左括号不⽤⼊栈到num）4、如果中缀表达式扫描完了，那么将opera中的操作数依次出栈，并⼊栈到num中就可以了，如果没有没有扫描完重复1-3步上⾯就是中缀表达式转后缀表达式的步骤了，下⾯⽤图来直观的了解⼀下这个过程需要注意的是：opera中操作数，越靠近栈顶，优先级越⾼，下⾯附上实现代码View Code后缀表达式的计算完成了中缀表达式转后缀表达式，接下来就是后缀表达式的计算了，后缀表达式的计算⽐中缀转后缀要稍微简单⼀点，只需要对我们转换好的后缀表达式从左往右依次扫描，并依次⼊栈就⾏了，意思是只需要⽤⼀个数组（double num[100]）就OK了需要考虑的情况如下1、如果是数字，那么直接⼊栈到num中2、如果是运算符，将栈顶的两个数字出栈（因为我们考虑的运算符加、减、乘、除都是双⽬运算符，只需要两个操作数），出栈后对两个数字进⾏相应的运算，并将运算结果⼊栈3、直到遇到'\0'下⾯⽤⼏张图，来直观了解下这个过程，以上⾯转换好的后缀表达式"123+*"为例（这⾥⽤ss来存储后缀表达式，num来存储计算结果，注意不要与上⾯图中num搞混淆了）（注意：这⾥将计算结果5⼊栈后，栈顶从之前的[3]变成[2]）到这⾥后缀表达式的计算就结束了，下⾯附上实现代码[](javascript:void(0)1 #include <stdio.h>2 #include <stdlib.h>34 #define MAX 10056 void JudgeFopen_s(errno_t err); /* 判断⽂件打开是否成功 */7 void ReadFile(FILE *fp, char *ss); /* 读取⽂件内容 */8 double TransformCtoD(char ch); /* 将char类型数组的每⼀个元素转换为double */9 void CalculateAndPush(double *num, int *i, int *j, char mm); /* 计算结果并⼊栈 */1011 int main()12 {13 FILE *fp;14 errno_t err;1516 char ss[MAX]; /* 存储逆波兰表达式 */17 int i = 0;18 int j = 0;19 double num[MAX]; /* 栈 */2021 err = fopen_s(&fp, "E:\\ww.txt", "r");2223 JudgeFopen_s(err); /* 判断⽂件打开是否成功 */24 ReadFile(fp, ss); /* 读取⽂件内容，存储到ss中*/2526 while (ss[i] != '\0')27 {28 if (ss[i] >= '0' && ss[i] <= '9') /* 如果是数字 */29 {30 /* 因为num是char类型的，需要转换为double类型⽅便计算 */31 num[j] = TransformCtoD(ss[i]); /* 将数字存储到栈中 */32 j++;33 i++;34 }35 else if (ss[i] == '+' || ss[i] == '-' || ss[i] == '*' || ss[i] == '/')36 {37 CalculateAndPush(num, &i, &j, ss[i]); /* 计算结果并⼊栈 */38 }39 else if (ss[i] == '\n') /* 如果是换⾏符，结束循环*/40 {41 break;42 }43 }4445 printf("%lf", num[0]);4647 return 0;48 }4950 /* Function: 计算结果并⼊栈 */51 void CalculateAndPush(double *num, int *i, int *j, char mm)52 {53 switch (mm)54 {55 case '+':56 {57 num[(*j)-2] = num[(*j)-1] + num[(*j)-2];58 (*j)--;59 (*i)++;60 break;61 }62 case '-':63 {64 num[(*j)-2] = num[(*j)-1] - num[(*j)-2];65 (*j)--;66 (*i)++;67 break;68 }69 case '*':70 {71 num[(*j)-2] = num[(*j)-1] * num[(*j)-2];72 (*j)--;73 (*i)++;74 break;75 }76 case '/':77 {78 num[(*j)-2] = num[(*j)-1] / num[(*j)-2];79 (*j)--;80 (*i)++;81 break;82 }83 default:84 {85 exit(0);86 }87 }88 }89 /* Function: 判断⽂件打开是否成功 */90 void JudgeFopen_s(errno_t err)91 {92 if (err != 0)93 {94 printf("⽂件打开失败\n");95 system("pause");96 exit(0);97 }98 }99100 /* Function: 读取⽂件内容*/101 void ReadFile(FILE *fp, char *ss)102 {103 int i = 0;104105 while (!feof(fp))106 {107 fscanf_s(fp, "%c", &ss[i]);108 i++;109 }110 ss[i-1] = '\0';111 }112113 /* Function: 将char类型数组的每⼀个元素转换为double */ 114 double TransformCtoD(char ch)115 {116 return (double)(ch - '0');117 }。
数据结构之中缀表达式转后缀表达式
return NULL;
}
S->Next = NULL;
MakeEmpty(S);
return S;
}
//清空栈
void MakeEmpty(Stack S)
{
if(S == NULL)
{
printf("Use CreateStack First!");
{
return 3;
}
else
{
fprintf(stderr,"Input char is invalid!\n");
return -1;
}
}
/****************************************************************
*判断一个字符是不是运算符
*如果是合法的运算符+、-、*、/、(、)则返回0，否则返回1
}
else
{
while(!IsEmpty(S))
{
Pop(S);
}
}
}
//进栈
void Push(ElementType X,Stack S)
{
PtrToNode Tmp;
Tmp = malloc(sizeof(struct Node));
if(Tmp != NULL)
{
Tmp->Element = X;
遇到a，直接输出：
遇到+，此时栈为空，入栈：
遇到b，直接输出：
遇到*,优先级大于栈顶符号优先级，入栈：
遇到c，输出：
遇到+，目前站内的*与+优先级都大于或等于它，因此将栈内的*，+依次弹出并且输出，并且将遇到的这个+入栈：
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
中缀表达式转换为后缀表达式课程设计任务：中缀表达式转后缀表达式，并求值。
课程设计思路：把中缀表达式转换为后缀表达式算法的基本思路是从头到尾地扫描中缀表达式中的每个字符，对于不同类型的字符按不情况进行处理。
若遇到的是空格则认为是分隔符，不需要进行处理；若遇到的是数字或小数点，则直接写入到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、扫描完成后，取出栈中所有运算符，写入后缀表达式数组。
主要代码：#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define MAXNUM 100typedef int DataType;struct SeqStack {DataType s[MAXNUM];int t;};typedef struct SeqStack *PSeqStack;PSeqStack createEmptyStack_seq() { //建立空栈PSeqStack pastack;pastack = (PSeqStack)malloc(sizeof(struct SeqStack));if (pastack == NULL)printf("空间溢出!!\n");elsepastack->t = -1;return pastack;}int isEmptyStack_seq(PSeqStack pastack){return pastack->t == -1;}void push_seq(PSeqStack pastack, DataType x){if (pastack->t >= MAXNUM - 1)printf("溢出!\n");else{pastack->t = pastack->t + 1;pastack->s[pastack->t] = x;}}void pop_seq(PSeqStack pastack){if (pastack->t == -1)printf("错误!\n");elsepastack->t = pastack->t - 1;}DataType top_seq(PSeqStack pastack){return pastack->s[pastack->t];}int infixtoSuffix(const char * infix, char * suffix){ //将中缀表达式转换为后缀表达式，顺利转换返回true，若转换过程中发现中缀表达式非法则返回false int state_int = FALSE;//state_int记录状态，等于true表示刚读入的是数字字符，等于false表示刚读入的不是数字字符，//设置这个变量是为了在每输出一个整数后输出一个空格，以免连续输出的两个整数混在一起。
char c, c2;PSeqStack ps = createEmptyStack_seq(); //运算符栈int i, j = 0;if (infix[0] == '\0')return FALSE; //不允许出现空表达式for (i = 0; infix[i] != '\0'; i++){c = infix[i];switch (c){case ' ':case '\t':case '\n':if (state_int == TRUE)suffix[j++] = ' ';//状态从true转换为false时输出一个空格state_int = FALSE;break; //遇到空格或制表符忽略case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':state_int = TRUE;suffix[j++] = c; //遇到数字输出break;case '(':if (state_int == TRUE)suffix[j++] = ' ';//状态从true转换为false时输出一个空格state_int = FALSE;push_seq(ps, c); //遇到左括号，入栈break;case ')':if (state_int == TRUE)suffix[j++] = ' ';//状态从true转换为false时输出一个空格state_int = FALSE;c2 = ')';while (!isEmptyStack_seq(ps)){c2 = top_seq(ps);//取栈顶pop_seq(ps); //出栈if (c2 == '('){break;}suffix[j++] = c2;}if (c2 != '('){free(ps);suffix[j++] = '\0';return FALSE;}break;case '+':case '-':if (state_int == TRUE)suffix[j++] = ' ';state_int = FALSE;while(!isEmptyStack_seq(ps)){c2 = top_seq(ps);if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/'){pop_seq(ps);suffix[j++] = c2;}else if(c2=='(') break;}push_seq(ps, c);break;case '*':case '/':if (state_int == TRUE)suffix[j++] = ' ';state_int = FALSE;while (!isEmptyStack_seq(ps)){c2 = top_seq(ps);if (c2 == '*' || c2 == '/'){pop_seq(ps);suffix[j++] = c2;}else if(c2=='+'||c2=='-'||c2=='(') break;}push_seq(ps, c);break;default:free(ps);suffix[j++] = '\0';return FALSE;}}if (state_int == TRUE) suffix[j++] = ' ';while (!isEmptyStack_seq(ps)){c2 = top_seq(ps);pop_seq(ps);if (c2 == '('){free(ps);suffix[j++] = '\0';return FALSE;}suffix[j++] = c2;}free(ps);suffix[j++] = '\0';return TRUE;}int calculateSuffix(const char * suffix, int * presult) {int state_int = FALSE;PSeqStack ps = createEmptyStack_seq();int num = 0, num1, num2;int i;char c;for (i = 0; suffix[i] != '\0'; i++){c = suffix[i];switch (c){case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':if (state_int == TRUE)num = num * 10 + c - '0'; else num = c - '0';state_int = TRUE;break;case ' ':case'\t':case '\n':if (state_int == TRUE){push_seq(ps, num);state_int = FALSE;}break;case '+':case '-':case '*':case '/':if (state_int == TRUE){push_seq(ps, num);state_int = FALSE;}if (isEmptyStack_seq(ps)) {free(ps);return FALSE;}num2 = top_seq(ps);pop_seq(ps);if (isEmptyStack_seq(ps)) {free(ps);return FALSE;}num1 = top_seq(ps);pop_seq(ps);if (c == '+')push_seq(ps, num1 + num2); if (c == '-')push_seq(ps, num1 - num2); if (c == '*')push_seq(ps, num1 * num2);if (c == '/')push_seq(ps, num1 / num2);break;default:free(ps);return FALSE;}}*presult = top_seq(ps);pop_seq(ps);if (!isEmptyStack_seq(ps)){free(ps);return FALSE;}free(ps);return TRUE;} void getline(char * line, int limit){char c;int i = 0;while (i < limit - 1 && (c = getchar()) != EOF && c != '\n') line[i++] = c;line[i] = '\0';} void main(){ char c, infix[MAXNUM], suffix[MAXNUM];int result;int flag = TRUE;while (flag == TRUE){printf("请输入一个中缀表达式,以回车结束!\n输入:"); getline(infix, MAXNUM);if(infixtoSuffix(infix, suffix) == TRUE)printf("后缀表达式:%s\n", suffix);else{printf("无效的中缀表达式!\n");printf("\n继续? (y/n)");scanf("%c", &c);if (c == 'n' || c == 'N') flag = FALSE;while (getchar() != '\n');printf("\n");continue;}if(calculateSuffix(suffix, &result) == TRUE)printf("运算结果:%d\n", result);elseprintf("您输入的是后缀表达式,请输入中缀表达式!\n");printf("\n继续? (y/n)");scanf("%c", &c);if (c == 'n' || c == 'N') flag = FALSE;while (getchar() != '\n');printf("\n");}}调试过程中出现的各种问题及解决办法我在调试过程中出现了连续输出的两个整数混在一起，造成无法分辨是一个整数，还是几个整数的问题。