表达式

 

表达式

Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^

题目描述

题目链接：http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2549

      算术表达式的求值我们在小学的时候就已经熟练掌握了。给出若干个只含加减乘的表达式你的任务是计算出结果。为了简化计算，给定的表达式的运算符只包含 ‘+’、‘-’、‘*’。运算符优先级为‘*’ ＞ ‘＋’ = ‘-’。

输入

输入数据的第一行为一个正整数 T (T <= 100)，表示有 T 组测试数据。
对于每组测试数据，输入一行表达式，由数字、运算符组成，且数字和运算符之间没有空格。数字均为整数, 运算符为 ‘+’,‘ –’,‘*’ 中的一个，表达式字符串长度<=100。
数字保证没有前导0，任意两个数字之间有且仅有一个运算符（不会出现3--2 等情况），运算中间结果及最终结果保证在int范围内。

输出

对于每组测试数据，输出表达式的结果。

示例输入

1

1-2*3

示例输出

-5

测试数据全都正确，但是提交上总是wrong answer，个人认为应该是整数的问题，在本代码中，整数的取值范围是0~9，一旦超出，就会出错；
思路就是先转换成后缀式，再由后缀式求值。

  1 #include<stdio.h>

  2 #include<string.h>

  3 #include<stdlib.h>

  4 char zhan[300];

  5 int top=-1;

  6 void ruzhan(char ch)

  7 {

  8     zhan[++top]=ch;

  9 }

 10 int cmp(char ch)

 11 {

 12     if(ch=='+'||ch=='-')return 1;

 13     if(ch=='*'||ch=='/')return 2;

 14     if(ch=='(')return 3;

 15 }

 16 int main()

 17 {

 18     int zong ;

 19     //while(scanf("%d",&zong)!=EOF)

 20     scanf("%d",&zong );

 21     {

 22         while(zong--)

 23         {

 24             top=-1;

 25             char g[300];

 26             int t=-1;

 27             char f[300];

 28             scanf("%s",f);

 29             int len=strlen(f);

 30             int i;

 31             for(i=0; i<=len-1; i++)

 32             {

 33                 if((f[i]>='0'&&f[i]<='9')||(f[i]>='a'&&f[i]<='z'))

 34                     g[++t]=f[i];

 35                 else//如果是运算符的话

 36                 {

 37                     if(f[i]=='(')ruzhan(f[i]);//运算符是左括号

 38                     else if(f[i]==')')//运算符是右括号

 39                     {

 40                         for(; zhan[top]!='('; top--)

 41                         {

 42                             g[++t]=zhan[top];

 43                         }

 44                         --top;

 45                     }

 46                     else//运算符是加减乘除运算符中的一种运算符

 47                     {

 48                         if(cmp(f[i])>cmp(zhan[top]))//当前运算符优先级大于栈顶运算符的优先级

 49                             ruzhan(f[i]);

 50                         else//当前运算符优先级小于等于栈顶运算符优先级

 51                         {

 52                             if(zhan[top]=='(')ruzhan(f[i]);//栈顶运算符是左括号的特殊情况

 53                             else//栈顶运算符是加减乘除四种运算符的一种

 54                             {

 55                                 while(cmp(f[i])<=cmp(zhan[top]))//当前运算符优先级小于等于栈顶运算符优先级的时候执行循环体

 56                                 {

 57                                     g[++t]=zhan[top];

 58                                     top--;

 59                                 }

 60                                 ruzhan(f[i]);

 61                             }

 62                         }

 63                     }

 64                 }

 65             }

 66             for(; top>=0; top--)

 67                 g[++t]=zhan[top];

 68             /*//验证输出后缀式

 69             for(i=0;i<=t;i++)

 70             printf("%c",g[i]);

 71             printf("\n");

 72             */

 73             int h[300];

 74             top=-1;

 75             int sum;

 76             for(i=0; i<=t; i++)

 77             {

 78                 if(g[i]>='0'&&g[i]<='9')

 79                 {

 80                     h[++top]=g[i]-'0';

 81                 }

 82                 else

 83                 {

 84                     switch(g[i])

 85                     {

 86                     case '+':

 87                         sum=h[top-1]+h[top];

 88                         break;

 89                     case '-':

 90                         sum=h[top-1]-h[top];

 91                         break;

 92                     case '*':

 93                         sum=h[top-1]*h[top];

 94                         break;

 95                     case '/':

 96                         sum=h[top-1]/h[top];

 97                         break;

 98                     }

 99                     top=top-2;

100                     h[++top]=sum;

101                 }

102             }

103             printf("%d\n",h[0]);

104         }

105     }

106     return 0;

107 }

View Code

 9月27号：

正确的代码是：

  1 #include<iostream>

  2 #include<string.h>

  3 using namespace std;

  4 struct vode

  5 {

  6     int date;

  7     int flag1;

  8     char ch;

  9     int flag2;

 10 };

 11 int cmp(char ch)

 12 {

 13     if(ch=='+'||ch=='-')return 1;

 14     if(ch=='*'||ch=='/')return 2;

 15     if(ch=='(')return 3;

 16 }

 17 int zhuanhuan(int n)

 18 {

 19     int i,sum=1;

 20     for(i=0;i<=n-1;i++)

 21         sum*=10;

 22     return sum;

 23 }

 24 int zhuanzhi(char f[],int t)

 25 {

 26     int i,s=t;

 27     int sum=0;

 28     for(;t>=0;t--)

 29     {

 30         sum+=zhuanhuan(s-t)*(f[t]-'0');

 31     }

 32     return sum;

 33 }

 34 void hanshu(struct vode f[],int n);

 35 int main()

 36 {

 37     int zong ;

 38     cin>>zong ;

 39     while(zong--)

 40     {

 41         char f[106];

 42         char zhan[106];

 43         int top=-1;

 44         struct vode bds[106];

 45         memset(bds,0,sizeof(bds));

 46         int t=-1;

 47         cin>>f;

 48         int lenth=strlen(f);

 49         int i,j;

 50         for(i=0;i<=lenth-1;i++)

 51         {

 52             int sum=0;

 53             if(f[i]>='0'&&f[i]<='9')

 54             {

 55                 char zs[105];

 56                 int st=-1;

 57                 i--;

 58                 int j=i;

 59                 do

 60                 {

 61                     i++;

 62                     j++;

 63                     zs[++st]=f[j];

 64                 }

 65                 while(f[j+1]>='0'&&f[j+1]<='9');

 66                 bds[++t].date=zhuanzhi(zs,st);

 67                 bds[t].flag1=1;

 68             }

 69             else

 70             {

 71                 if(f[i]=='(')

 72                 {

 73                     zhan[++top]='(';

 74                 }

 75                 else if(f[i]==')')

 76                 {

 77                     for(;zhan[top]!='(';top--)

 78                     {

 79                         bds[++t].ch=zhan[top];

 80                         bds[t].flag2=1;

 81                     }

 82                     top--;

 83                 }

 84                 else

 85                 {

 86                     if(cmp(zhan[top])<cmp(f[i]))

 87                     {

 88                         zhan[++top]=f[i];

 89                     }

 90                     else

 91                     {

 92                         while(cmp(zhan[top])>=cmp(f[i])&&zhan[top]!='(')

 93                         {

 94                             bds[++t].ch=zhan[top];

 95                             bds[t].flag2=1;

 96                             top--;

 97                         }

 98                         zhan[++top]=f[i];

 99                     }

100                 }

101             }

102         }

103         for(;top>=0;top--)

104         {

105             bds[++t].ch=zhan[top];

106             bds[t].flag2=1;

107         }

108         //验证输出

109         /*for(i=0;i<=t;i++)

110         {

111             if(bds[i].flag1)cout<<bds[i].date;

112             if(bds[i].flag2)cout<<bds[i].ch;

113         }

114         cout<<endl;*/

115         hanshu(bds,t);

116     }

117     return 0;

118 }

119 void hanshu(struct vode bds[],int s)

120 {

121     int i,t=-1;

122     int zhan[1008];

123     for(i=0;i<=s;i++)

124     {

125         if(bds[i].flag1)

126             zhan[++t]=bds[i].date;

127         else

128         {

129             switch(bds[i].ch)

130             {

131             case '+':

132                 zhan[t-1]=zhan[t-1]+zhan[t];break;

133             case '-':

134                 zhan[t-1]=zhan[t-1]-zhan[t];break;

135             case '*':

136                 zhan[t-1]=zhan[t-1]*zhan[t];break;

137             case '/':

138                 zhan[t-1]=zhan[t-1]/zhan[t];break;

139             }

140             t--;

141         }

142     }

143     cout<<zhan[0]<<endl;

144 }

View Code

 线性表代码：runtime error

  1 //线性表代码：re了

  2 #include<iostream>

  3 #include<string.h>

  4 #include<stdlib.h>

  5 using namespace std;

  6 const int maxx=1000;

  7 struct vode

  8 {

  9     int date;

 10     int flag1;

 11     char ch;

 12     int flag2;

 13 };

 14 typedef struct

 15 {

 16     struct vode *elem;

 17     int top;

 18     int stacksize;

 19 } hzsz;

 20 typedef struct

 21 {

 22     char *elem;

 23     int top;

 24     int stacksize;

 25 } ysfz;

 26 typedef struct

 27 {

 28     char *f;

 29     int length;

 30     int stacksize;

 31 } inz;

 32 int cmp(char ch);

 33 void inite(hzsz &l1,ysfz &l2,inz &l3);

 34 int zhuanhuan(int n);

 35 int zhuanzhi(char f[],int t);

 36 void hzbds(inz &in,hzsz &hzs,ysfz &ysf);

 37 void qiuzhi(hzsz &hzs);

 38 int main()

 39 {

 40     int zong ;

 41     cin>>zong ;

 42     while(zong--)

 43     {

 44     hzsz hzs;

 45     ysfz ysf;

 46     inz in;

 47     inite(hzs,ysf,in);

 48     cin>>in.f;

 49     hzbds(in,hzs,ysf);

 50     }

 51     return 0;

 52 }

 53 int cmp(char ch)

 54 {

 55     if(ch=='+'||ch=='-')return 1;

 56     else if(ch=='*'||ch=='/')return 2;

 57     else if(ch=='(')return 3;

 58 }

 59 void inite(hzsz &l1,ysfz &l2,inz &l3)

 60 {

 61     l1.elem=(struct vode *)malloc(maxx*sizeof(struct vode));

 62     //memset(l1.elem,0,sizeof(l1.elem));

 63     int i;

 64     for(i=0;i<=999;i++)

 65     {

 66         l1.elem[i].flag1=0;

 67         l1.elem[i].flag2=0;

 68     }

 69     l1.stacksize=maxx;

 70     l1.top=-1;

 71     l2.elem=(char *)malloc(maxx*sizeof(char));

 72     l2.stacksize=maxx;

 73     l2.top=-1;

 74     l3.f=(char *)malloc(maxx*sizeof(char));

 75     l3.stacksize=maxx;

 76 }

 77 int zhuanhuan(int n)

 78 {

 79     int i,sum=1;

 80     for(i=0; i<=n-1; i++)

 81         sum*=10;

 82     return sum;

 83 }

 84 int zhuanzhi(char f[],int t)

 85 {

 86     int s=t;

 87     int sum=0;

 88     for(; t>=0; t--)

 89     {

 90         sum+=zhuanhuan(s-t)*(f[t]-'0');

 91     }

 92     return sum;

 93 }

 94 void hzbds(inz &in,hzsz &hzs,ysfz &ysf)

 95 {

 96     in.length=strlen(in.f);

 97     int i;

 98     for(i=0; i<=in.length-1; i++)

 99     {

100         if(in.f[i]>='0'&&in.f[i]<='9')

101         {

102             char zs[106];

103             int st=-1;

104             i--;

105             do

106             {

107                 i++;

108                 zs[++st]=in.f[i];

109             }

110             while(in.f[i+1]>='0'&&in.f[i+1]<='9');

111             hzs.elem[++hzs.top].date=zhuanzhi(zs,st);

112             hzs.elem[hzs.top].flag1=1;

113         }

114         else

115         {

116             if(in.f[i]=='(')

117             {

118                 ysf.elem[++ysf.top]=in.f[i];

119             }

120             else if(in.f[i]==')')

121             {

122                 for(; ysf.elem[ysf.top]!='('; ysf.top--)

123                 {

124                     hzs.elem[++hzs.top].ch=ysf.elem[ysf.top];

125                     hzs.elem[hzs.top].flag2=1;

126                 }

127                 ysf.top--;

128             }

129             else

130             {

131                 if(ysf.top==-1)

132                 {

133                     ysf.elem[++ysf.top]=in.f[i];

134                 }

135                 else if(cmp(ysf.elem[ysf.top])<cmp(in.f[i]))

136                 {

137                 ysf.elem[++ysf.top]=in.f[i];

138                 }

139                 else

140                 {

141                     while(cmp(ysf.elem[ysf.top])>=cmp(in.f[i])&&ysf.elem[ysf.top]!='('&&ysf.elem[i]!=-1)

142                     {

143                         hzs.elem[++hzs.top].ch=ysf.elem[ysf.top];

144                         hzs.elem[hzs.top].flag2=1;

145                         ysf.top--;

146                     }

147                     ysf.elem[++ysf.top]=in.f[i];

148                 }

149             }

150         }

151     }

152     for(; ysf.top>=0; ysf.top--)

153     {

154         hzs.elem[++hzs.top].ch=ysf.elem[ysf.top];

155         hzs.elem[hzs.top].flag2=1;

156     }

157     /*验证输出

158     for(i=0; i<=t; i++)

159     {

160         if(hzs.elem[i].flag1==1)cout<<hzs.elem[i].date<<" ";

161         if(hzs.elem[i].flag2==1)cout<<hzs.elem[i].ch<<" ";

162         //else cout<<hzs.elem[i].ch;

163        // cout<<hzs.elem[i].flag1<<hzs.elem[i].date<<endl;

164         //cout<<hzs.elem[i].flag2<<hzs.elem[i].ch<<endl<<endl;

165     }

166     cout<<endl;*/

167     qiuzhi(hzs);

168 }

169 void qiuzhi(hzsz &hzs)

170 {

171     double number[106];

172     int st=-1,i;

173     for(i=0;i<=hzs.top;i++)

174     {

175         if(hzs.elem[i].flag1==1)

176         {

177             number[++st]=hzs.elem[i].date;

178         }

179         else

180         {

181             switch (hzs.elem[i].ch)

182             {

183             case '+':number[st-1]=number[st-1]+number[st];break;

184             case '-':number[st-1]=number[st-1]-number[st];break;

185             case '*':number[st-1]=number[st-1]*number[st];break;

186             case '/':number[st-1]=number[st-1]/number[st];break;

187             }

188             st--;

189         }

190     }

191     cout<<number[0]<<endl;

192 }

View Code