表达式

表达式

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

 

posted @ 2013-08-21 10:28  狂盗一枝梅  阅读(444)  评论(0)  编辑  收藏  举报