[基础算法]通过后缀表达式实现表达式的计算

要求说明：

（1）从键盘接收算术表达式，以“#”表示接收结束；
（2）输出算术表达式的值；
（3）操作数仅限于非负整数，操作符只能是+、-、*、/、^、（、）
（4）可以判断表达式的合法性（如括号的匹配）

写作业时遇到的一道题目，觉得比较麻烦，估计以后会有人遇到相同的问题，就写了篇博客记录下来。

主要思路：

(1)先将表达式转化成后缀表达式
(2)逐个读取后缀表达式，计算结果

转化成后缀表达式：

(1)设立操作符栈。
(2)设表达式的结束符为“#”，预设操作符栈的栈底为“#”。
(3)若当前字符是操作数,则直接发送给后缀式。
(4)若当前字符为操作符且优先级大于栈顶操作符，则人栈，否则退出栈顶操作符发送给后缀式。
(5)若当前字符是结束符，则自栈顶至栈底依次将栈中所有操作符发送给后缀式。
(6)“(”对它之前后的操作符起隔离作用，则若当前操作符为“(”时人栈。
(7)“)”可视为自相应左括号开始表达式的结束符，则从栈顶起，依次退出栈顶操作
符发送给后缀式直至栈顶字符为“("止。“(”不发送到后缀式。

转化成后缀表达式函数代码：

/*SeqStack *L操作符栈，char *str1读取的表达式，char *str2返回的后缀表达式*/
void Conversion(SeqStack *S,char *str1,char *str2)
{int i=0;char *p=str1,e;//预设操作符栈的栈底为“#”Push(S,'#');while (*p!='\0'){//若当前字符不是操作符是操作数,则直接发送给后缀式。if (!Isoperator(*p)){str2[i++]=*p;}else{if (*p=='(')Push(S,*p);else if (*p==')'){while(GetTop(S)!='('){Pop(S,&e);str2[i++]=e;}Pop(S,&e);  /*pop掉前括号*/}else if (*p=='#'){while (!IsEmpty(S)){Pop(S,&e);str2[i++]=e;}}else if (Compare(*p,GetTop(S))){Push(S,*p);}else if (!Compare(*p,GetTop(S))){Pop(S,&e);str2[i++]=e;continue;  /*continue应该要加*/}}p++;}str2[i-1]='\0';  /*#号也存进去了，所以用'\0'覆盖掉*/
}

完整计算表达式代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#define TRUE 1
#define FALSE 0
#define Stack_Size 50char ops[8]= {'+','-','*','/','(',')','^','#'}; /*运算符数组*/
int priority[8] = {1,1,2,2,0,0,3,-1};typedef struct
{char elem[Stack_Size];int top;
} SeqStack;    /*运算符栈的定义*/typedef struct
{int elem[Stack_Size];int top;
} nSeqStack;  /* 运算数栈的定义*/void InitStack(SeqStack *S)   /*初始化运算符栈*/
{S->top =-1;
}void InitStackn(nSeqStack *S)   /*初始化运算数栈*/
{S->top =-1;
}int IsEmpty(SeqStack *S)    /*判断栈S为空栈时返回值为真，反之为假*/
{return(S->top==-1?TRUE:FALSE);
}int IsEmptyn(nSeqStack *S)    /*判断栈S为空栈时返回值为真，反之为假*/
{return(S->top==-1?TRUE:FALSE);
}/*判栈满*/
int IsFull(SeqStack *S)     /*判断栈S为满栈时返回值为真，反之为假*/
{return(S->top==Stack_Size-1?TRUE:FALSE);
}int IsFulln(nSeqStack *S)      /*判断栈S为满栈时返回值为真，反之为假*/
{return(S->top==Stack_Size-1?TRUE:FALSE);
}int Push(SeqStack *S, char x)   /*运算符栈入栈函数*/
{if (S->top==Stack_Size-1){printf("Stack is full!\n");return FALSE;}else{S->top++;S->elem[S->top]=x;return TRUE;}
}int Pushn(nSeqStack *S, int x)   /*运算数栈入栈函数*/
{if (S->top==Stack_Size-1){printf("Stack is full!\n");return FALSE;}else{S->top++;S->elem[S->top]=x;return TRUE;}
}int Pop(SeqStack *S, char *x)    /*运算符栈出栈函数*/
{if (S->top==-1){printf("运算符栈空!\n");return FALSE;}else{*x=S->elem[S->top];S->top--;return TRUE;}
}int Popn(nSeqStack *S, int *x)    /*运算数栈出栈函数*/
{if (S->top==-1){printf("运算数栈空!\n");return FALSE;}else{*x=S->elem[S->top];S->top--;return TRUE;}
}char GetTop(SeqStack *S)    /*运算符栈取栈顶元素函数*/
{if (S->top ==-1){printf("运算符栈为空!\n");return FALSE;}else{return (S->elem[S->top]);}
}int GetTopn(nSeqStack *S)    /*运算数栈取栈顶元素函数*/
{if (S->top ==-1){printf("运算符栈为空!\n");return FALSE;}else{return (S->elem[S->top]);}
}int Isoperator(char ch)        /*判断输入字符是否为运算符函数,是返回TRUE,不是返回FALSE*/
{int i;for (i=0; i<8; i++){if(ch==ops[i])return TRUE;}return FALSE;
}int Compare(char c1,char c2)
{int m,n;/*赋值c1对应的n*/if (c1=='+' || c1=='-')m=1;else if (c1=='*' || c1=='/')m=2;else if (c1=='(' || c1==')')m=0;else if (c1=='^')m=3;else if (c1=='#')m=-1;/*赋值c2对应的n*/if (c2=='+' || c2=='-')n=1;else if (c2=='*' || c2=='/')n=2;else if (c2=='(' || c2==')')n=0;else if (c2=='^')n=3;else if (c2=='#')n=-1;return m>n;
}/*SeqStack *L操作符栈，char *str1读取的表达式，char *str2返回的后缀表达式*/
void Conversion(SeqStack *S,char *str1,char *str2)
{int i=0;char *p=str1,e;//预设操作符栈的栈底为“#”Push(S,'#');while (*p!='\0'){//若当前字符不是操作符是操作数,则直接发送给后缀式。if (!Isoperator(*p)){str2[i++]=*p;}else{if (*p=='(')Push(S,*p);else if (*p==')'){while(GetTop(S)!='('){Pop(S,&e);str2[i++]=e;}Pop(S,&e);  /*pop掉前括号*/}else if (*p=='#'){while (!IsEmpty(S)){Pop(S,&e);str2[i++]=e;}}else if (Compare(*p,GetTop(S))){Push(S,*p);}else if (!Compare(*p,GetTop(S))){Pop(S,&e);str2[i++]=e;continue;  /*continue应该要加*/}}p++;}str2[i-1]='\0';  /*#号也存进去了，所以用'\0'覆盖掉*/
}int Calc(char *str)
{nSeqStack *n,nn;n=&nn;int i;int x,y,result;char *p=str;InitStackn(n);while (*p!='\0'){if (!Isoperator(*p)){Pushn(n,*p-'0');}else{Popn(n,&x);Popn(n,&y);switch (*p){case '+':result=y+x;break;case '-':result=y-x;break;case '*':result=y*x;break;case '/':result=y/x;   /*假设都能整除*/break;case '^':result=y;for (i=1;i<x;i++){result=result*y;}break;default:printf("error\n");break;}Pushn(n,result);}p++;}return result;
}int main()
{/**整体步骤*(1)表达式转化成后缀表达式*(2)表达式逐个读取进行计算*/char str1[100],str2[100];scanf("%s",str1);SeqStack *s,ss;s=&ss;InitStack(s);Conversion(s,str1,str2);printf("后缀表达式：%s\n",str2);int result = Calc(str2);printf("表达式结果：%d\n",result);return 0;
}

附：

利用后缀表达式求解，只需要从左向右依次扫描表达式，
(1)遇到操作数人栈，
(2)遇到操作符.则做出栈两次，获得两个操作数，
后出栈的操作数为第一个操作对象，对它们进行计算，
计算结果作为下次运算的操作数入栈。
重复上述操作，直到后缀表达式读取结束，既可完成表达式的计算。