计算器（表达式计算-后缀表达式实现）

Posted 2021-02-07 tuoniao

【问题描述】

从标准输入中读入一个整数算术运算表达式，如24 / ( 1 + 2 + 36 / 6 / 2 - 2) * ( 12 / 2 / 2 )= ，计算表达式结果，并输出。

要求：

1、表达式运算符只有+、-、*、/，表达式末尾的=字符表示表达式输入结束，表达式中可能会出现空格；
2、表达式中会出现圆括号，括号可能嵌套，不会出现错误的表达式；

3、出现除号/时，以整数相除进行运算，结果仍为整数，例如：5/3结果应为1。

4、要求采用逆波兰表达式来实现表达式计算。

 

 

【输入形式】

从键盘输入一个以=结尾的整数算术运算表达式。操作符和操作数之间可以有空格分隔。

【输出形式】

在屏幕上输出计算结果（为整数，即在计算过程中除法为整除）。

【样例输入】

24 / ( 1 + 2 + 36 / 6 / 2 - 2) * ( 12 / 2 / 2 )     =

 

【样例输出】

18
【样例说明】

按照运算符及括号优先级依次计算表达式的值。

 

【题解】

  1 #include<stdio.h>
  2 #include<malloc.h>
  3 #include<stdlib.h>
  4 
  5 #define MAXSIZE 100
  6 
  7 typedef struct
  8 {
  9     char stcak[MAXSIZE];
 10     int top;
 11 }Sequence;
 12 typedef struct
 13 {
 14     int data[MAXSIZE];
 15     int top;
 16 }Operate;
 17 
 18 int isEmpty(Sequence *s);
 19 int push(Sequence *s,char c);
 20 int pop(Sequence *s,char *c);
 21 int getTop(Sequence *s,char *c);
 22 void translate(char s1[],char s2[]);
 23 int calculate(char a[]);
 24 
 25 int main(void)
 26 {
 27     char str1[MAXSIZE],str2[MAXSIZE];
 28     int result;
 29     fgets(str1,100,stdin);
 30     translate(str1,str2);
 31     result=calculate(str2);
 32     printf("%d
",result);
 33 
 34     return 0;
 35 }
 36 
 37 int isEmpty(Sequence *s)
 38 {
 39     if(-1==s->top)
 40         return 1;
 41     else
 42         return 0;
 43 }
 44 int push(Sequence *s,char c)
 45 {
 46     if(MAXSIZE==s->top)
 47         return 0;
 48 
 49     s->top++;
 50     s->stcak[s->top]=c;
 51     return 1;
 52 }
 53 int pop(Sequence *s,char *c)
 54 {
 55     if(isEmpty((s)))
 56         return 0;
 57 
 58     *c=s->stcak[s->top];
 59     s->top--;
 60     return 1;
 61 }
 62 int getTop(Sequence *s,char *c)
 63 {
 64     if(isEmpty((s)))
 65         return 0;
 66 
 67     *c=s->stcak[s->top];
 68     return 1;
 69 }
 70 void translate(char s1[],char s2[])
 71 {
 72     Sequence s;
 73     char ch,e=‘‘;
 74     int i=0,j=0;
 75     s.top=-1;
 76     ch=s1[i++];
 77     while(ch!=‘=‘)
 78     {
 79         switch(ch)
 80         {
 81             case ‘(‘:
 82                 push(&s,ch);
 83                 break;
 84             case ‘)‘:
 85                 while(getTop(&s,&e) && e!=‘(‘)
 86                 {
 87                     pop(&s,&e);
 88                     s2[j++]=e;
 89                 }
 90                 pop(&s,&e);
 91                 break;
 92             case ‘+‘:
 93             case ‘-‘:
 94                 while(!isEmpty(&s) && getTop(&s,&e) && e!=‘(‘)
 95                 {
 96                     pop(&s,&e);
 97                     s2[j++]=e;
 98                 }
 99                 push(&s,ch);
100                 break;
101             case ‘*‘:
102             case ‘/‘:
103                 while(!isEmpty(&s) && getTop(&s,&e) && (‘/‘==e || ‘*‘==e) )
104                 {
105                     pop(&s,&e);
106                     s2[j++]=e;
107                 }
108                 push(&s,ch);
109                 break;
110             case ‘ ‘:
111                 break;
112             default:
113                 while(ch>=‘0‘ && ch<=‘9‘)
114                 {
115                     s2[j++]=ch;
116                     ch=s1[i++];
117                 }
118                 i--;
119                 s2[j++]=‘ ‘;
120         }
121         ch=s1[i++];
122     }
123     while(!isEmpty(&s))
124     {
125         pop(&s,&e);
126         if(e!=‘ ‘)
127             s2[j++]=e;
128     }
129     s2[j]=‘‘;
130 }
131 int calculate(char a[])
132 {
133     Operate s;
134     int i=0,data,result=0;
135     int x1,x2;
136     s.top=-1;
137     while(a[i]!=‘‘)
138     {
139         if(a[i]>=‘0‘ && a[i]<=‘9‘)
140         {
141             data=0;
142             while(a[i]!=‘ ‘)
143             {
144                 data=data*10+a[i]-‘0‘;
145                 i++;
146             }
147             s.top++;
148             s.data[s.top]=data;
149         }
150         else
151         {
152             switch(a[i])
153             {
154                 case ‘+‘:
155                     x1=s.data[s.top--];
156                     x2=s.data[s.top--];
157                     result=x1+x2;
158                     s.data[++s.top]=result;
159                     break;
160                 case ‘-‘:
161                     x1=s.data[s.top--];
162                     x2=s.data[s.top--];
163                     result=x2-x1;
164                     s.data[++s.top]=result;
165                     break;
166                 case ‘*‘:
167                     x1=s.data[s.top--];
168                     x2=s.data[s.top--];
169                     result=x1*x2;
170                     s.data[++s.top]=result;
171                     break;
172                 case ‘/‘:
173                     x1=s.data[s.top--];
174                     x2=s.data[s.top--];
175                     result=x2/x1;
176                     s.data[++s.top]=result;
177                     break;
178             }
179             i++;
180         }
181     }
182     if(s.top!=-1)
183         result=s.data[s.top--];
184 
185     return result;
186 }