软件工程个人作业03

1.设计思想：

①　在程序的开头询问需要的条件：

1>是否有乘除法；

2>是否有括号(最多可以支持十个数参与计算)；

3>数值范围；

4>加减有无负数；

5>除法有无余数（若前面询问的有无乘除法为无，则不再询问）；

6>一共有多少个式子；

②　设定一个二维数组，大小为number（总式子数量）X 10；

③　设定一个循环来监测有多少次有效的循环，当循环达到number时，结束程序；

否则，对各个位进行随机取值，并保存在数组里，随机产生一个数字来判定式子是有几个数字组成的，并随机产生每两个数字之间的运算符号，并且输出，之后计算结果，并保存在变量result中，并予以输出。

④与此同时进行结果的运算，运用栈来进行运算，并进行输出，记录运算结果。

2.源程序代码：

  1 import java.util.*;
  2 
  3 public class ThirdCalculate
  4 {
  5     int Operate(int a,char b,int c)
  6     {
  7         int d=0;
  8         
  9         if(b=='+')
 10         {
 11             d=a+b;
 12         }
 13         else if(b=='-')
 14         {
 15             d=a-b;
 16         }
 17         else if(b=='*')
 18         {
 19             d=a*b;
 20         }
 21         else if(b=='/')
 22         {
 23             d=a/b;
 24         }
 25         
 26         return d;
 27     }
 28     
 29     char Precede(char a,char b)
 30     {
 31         int x = 0,y = 0;
 32         char OPSET[]={')','+','-','*','/','('};
 33         
 34         for(int j=0;j<6;j++)
 35         {
 36             if(a==OPSET[j])
 37             {
 38                 x=j;
 39             }
 40             if(b==OPSET[j])
 41             {
 42                 y=j;
 43             }
 44         }
 45         
 46         if(x==0&&y==5)
 47         {
 48             return '$';
 49         }
 50         else if(x<y)
 51         {
 52             return '<';
 53         }
 54         else if(x>y)
 55         {
 56             return '>';
 57         }
 58         else
 59         {
 60             return '=';
 61         }
 62     }
 63     
 64     public static void main(String args[])
 65     {
 66         @SuppressWarnings("resource")
 67         Scanner in=new Scanner(System.in);
 68 //---------------要求规定---------
 69         System.out.print("请输入打印运算式的数量：");
 70         int number=in.nextInt();
 71         
 72         char symbollist[]=new char[4];
 73         System.out.print("①请问是否有乘除法（1：是 2：不是）：");
 74         int flag=in.nextInt();
 75         if(flag==1)
 76         {
 77             symbollist[0]='+';
 78             symbollist[1]='-';
 79             symbollist[2]='*';
 80             symbollist[3]='/';
 81         }
 82         else
 83         {
 84             symbollist[0]='+';
 85             symbollist[1]='-';
 86             symbollist[2]='+';
 87             symbollist[3]='-';
 88         }
 89         
 90         System.out.print("②请问是否有括号（1：是 2：不是）：");
 91         int boolbracket=in.nextInt();
 92         
 93         System.out.print("③请问需要数据范围是（先输入下界，后输入上界）：");
 94         double min=in.nextDouble();
 95         double max=in.nextDouble();
 96         
 97         System.out.print("④请问加减有无负数（1：有 2.无）：");
 98         int negative=in.nextInt();
 99         if(negative==2)
100         {
101             if(min<0)
102             {
103                 min=0;
104             }
105         }
106         
107         if(flag==1)
108         {
109             System.out.print("⑤除法有无余数（1：是 2：不是）：");
110             @SuppressWarnings("unused")
111             int boolremainder=in.nextInt();
112         }
113         System.out.println();
114         
115         
116         int space[][]=new int [number][10];
117         int symtime,time,correctNumber=0;
118         ThirdCalculate T=new ThirdCalculate ();
119         
120         for(time=0;time<number;)
121         {
122             for(int i=0;i<10;i++)
123             {
124                 space[time][i]=(int)(Math.random()*(max-min+1)+min);
125             }
126             
127             //判断所生成的数组中是否和之前产生的数组完全一致
128             int flag1=1;
129             for(int i=0;i<time;i++)
130             {
131                 for(int j=0;j<10;j++)
132                 {
133                     if(space[time][j]==space[i][j])
134                     {
135                         flag1=0;
136                     }
137                     else
138                     {
139                         flag1=1;
140                     }
141                 }
142             }
143             
144             //随机决定下面要产生的式子是由几个数字构成的
145             int s=(int)(Math.random()*(10-2+1)+2);
146             
147             //随机运算符
148             char p[]=new char [s-1];
149             for(int i=0;i<s-1;i++)
150             {
151                 symtime=(int)(Math.random()*(3-0+1)+0);
152                 p[i]=symbollist[symtime];
153             }
154 
155             //除号后不能有0的存在
156             for(int i=0;i<s-1;i++)
157             {
158                 if(p[i]=='/'&&space[time][i+1]==0)
159                 {
160                     flag1=0;
161                     break;
162                 }
163             }
164             
165             if(flag1==1)
166             {
167                 if(boolbracket==1&&s!=2)
168                 {
169                     System.out.print("(");
170                 }
171                 
172                 //若出现连续的除号，则在相应位置输出括号}
173                 int br1[]=new int [s];
174                 int br2[]=new int [s];
175                 for(int i=0;i<s-1;i++)
176                 {
177                     br1[i]=0;
178                     br2[i]=0;
179                 }
180                 for(int i=1;i<s-1;i++)
181                 {
182                     if(p[i-1]=='/'&&p[i]=='/')
183                     {
184                         br1[i-1]=1;
185                         br2[i]=1;
186                     }
187                 }
188                 
189                 //使用栈来完成结果的运算
190                 Stack<Integer> OPND=new Stack<Integer> ();
191                 Stack<Character> OPTR=new Stack<Character> ();
192                 OPTR.push('#');
193                 
194                 if(br1[0]==1)
195                 {
196                     System.out.print('(');
197                     OPTR.push('(');
198                 }
199                 System.out.print(space[time][0]);
200                 OPND.push(space[time][0]);
201                 
202                 for(int i=1;i<s;i++)
203                 {
204                     System.out.print(p[i-1]);
205                     if(T.Precede(OPTR.peek(),p[i-1])=='<')
206                     {
207                         OPTR.push(p[i-1]);
208                     }
209                     else if(T.Precede(OPTR.peek(),p[i-1])=='>'||T.Precede(OPTR.peek(),p[i-1])=='=')
210                     {
211                             char c;
212                             int a,b;
213                             c=OPTR.pop();
214                             a=OPND.pop();
215                             b=OPND.pop();
216                             OPND.push(T.Operate(a, c, b));
217                     }
218                     else if(T.Precede(OPTR.peek(),p[i-1])=='$')
219                     {
220                         OPTR.pop();
221                     }
222                     
223                     if(br1[i]==1)
224                     {
225                         System.out.print('(');
226                     }
227                     
228                     if(space[time][i]<0)
229                     {
230                         System.out.print('(');
231                         System.out.print(space[time][i]);
232                         OPND.push(space[time][i]);
233                         System.out.print(')');
234                     }
235                     else
236                     {
237                         System.out.print(space[time][i]);
238                         OPND.push(space[time][i]);
239                     }
240                     
241                     if(br2[i]==1)
242                     {
243                         System.out.print(')');
244                     }
245                     
246                     if(boolbracket==1&&i==(s-1)/2&&s!=2)
247                     {
248                         System.out.print(')');
249                         if(T.Precede(OPTR.peek(),')')=='<')
250                         {
251                             OPTR.push(')');
252                         }
253                         else if(T.Precede(OPTR.peek(),')')=='>'||T.Precede(OPTR.peek(),')')=='=')
254                         {
255                                 char c;
256                                 int a,b;
257                                 c=OPTR.pop();
258                                 a=OPND.pop();
259                                 b=OPND.pop();
260                                 OPND.push(T.Operate(a, c, b));
261                         }
262                         else if(T.Precede(OPTR.peek(),p[i-1])=='$')
263                         {
264                             OPTR.pop();
265                         }
266                     }
267                 }
268                 
269                 int realResult=OPND.peek();
270                 System.out.print("=");
271                 System.out.print("  请输入您认为正确的结果：");
272                 int yResult=in.nextInt();
273                 
274                 if(yResult==realResult)
275                 {
276                     System.out.println("结果正确");
277                     correctNumber++;
278                 }
279                 else
280                 {
281                     System.out.println("  结果错误，正确答案为："+realResult);
282                 }
283                 
284                 time++;
285             }
286         }
287         System.out.println("您答对的题数为"+correctNumber);
288     }
289 }

3.运行结果截图：

4.工作照片

5.编程总结分析：

　　经过这次编程，我感觉到了数据结构的作用，最然当时学的时候感觉用处不大，但是现在才发现，在实际编程序当中，其中的一些结构还是非常有用的，如栈、链表、二叉树，用好这些结构可以使我们的程序变得更加条理清楚，思路清晰，也更易实现。

6.项目计划总结：

	听课	编写程序	阅读课本	准备考试	日总结
周日			60		60
周一	120	60			180
周二
周三		120			120
周四
周五			60		60
周六		420			420
周总结	120	600	120		840

7.时间记录日志：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
3/20	16:00	17:00		60	读书	构建之法
3/21	8:00	10:10	20	100	上课
	14:00	15:00			写程序	想大概思路
3/23	16:00	18:00		120	写程序
3/25	15:00	15:30		30	读书
3/26	9:30	19:00	120	420	写程序

8.缺陷记录日志：

日期	编号	引入阶段	排除阶段	描述
3/26	01	编码	编码	java中栈的使用和分析
	02	编码	编码	变量类型使用错误，前后不符合
	03	编码	编码	计算结果时没有进行整体上的分析
	04	设计	设计	分类讨论时出现错误，没考虑完全