软件工程个人作业03

1.设计思想：

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

1>是否有乘除法；

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

3>数值范围；

4>加减有无负数；

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

6>一共有多少个式子；

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

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

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

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

2.源程序代码：

import java.util.*;

public class ThirdCalculate
{
    int Operate(int a,char b,int c)
    {
        int d=0;
        
        if(b=='+')
        {
            d=a+b;
        }
        else if(b=='-')
        {
            d=a-b;
        }
        else if(b=='*')
        {
            d=a*b;
        }
        else if(b=='/')
        {
            d=a/b;
        }
        
        return d;
    }
    
    char Precede(char a,char b)
    {
        int x = 0,y = 0;
        char OPSET[]={')','+','-','*','/','('};
        
        for(int j=0;j<6;j++)
        {
            if(a==OPSET[j])
            {
                x=j;
            }
            if(b==OPSET[j])
            {
                y=j;
            }
        }
        
        if(x==0&&y==5)
        {
            return '$';
        }
        else if(x<y)
        {
            return '<';
        }
        else if(x>y)
        {
            return '>';
        }
        else
        {
            return '=';
        }
    }
    
    public static void main(String args[])
    {
        @SuppressWarnings("resource")
        Scanner in=new Scanner(System.in);
//---------------要求规定---------
        System.out.print("请输入打印运算式的数量：");
        int number=in.nextInt();
        
        char symbollist[]=new char[4];
        System.out.print("①请问是否有乘除法（1：是 2：不是）：");
        int flag=in.nextInt();
        if(flag==1)
        {
            symbollist[0]='+';
            symbollist[1]='-';
            symbollist[2]='*';
            symbollist[3]='/';
        }
        else
        {
            symbollist[0]='+';
            symbollist[1]='-';
            symbollist[2]='+';
            symbollist[3]='-';
        }
        
        System.out.print("②请问是否有括号（1：是 2：不是）：");
        int boolbracket=in.nextInt();
        
        System.out.print("③请问需要数据范围是（先输入下界，后输入上界）：");
        double min=in.nextDouble();
        double max=in.nextDouble();
        
        System.out.print("④请问加减有无负数（1：有 2.无）：");
        int negative=in.nextInt();
        if(negative==2)
        {
            if(min<0)
            {
                min=0;
            }
        }
        
        if(flag==1)
        {
            System.out.print("⑤除法有无余数（1：是 2：不是）：");
            @SuppressWarnings("unused")
            int boolremainder=in.nextInt();
        }
        System.out.println();
        
        
        int space[][]=new int [number][10];
        int symtime,time,correctNumber=0;
        ThirdCalculate T=new ThirdCalculate ();
        
        for(time=0;time<number;)
        {
            for(int i=0;i<10;i++)
            {
                space[time][i]=(int)(Math.random()*(max-min+1)+min);
            }
            
            //判断所生成的数组中是否和之前产生的数组完全一致
            int flag1=1;
            for(int i=0;i<time;i++)
            {
                for(int j=0;j<10;j++)
                {
                    if(space[time][j]==space[i][j])
                    {
                        flag1=0;
                    }
                    else
                    {
                        flag1=1;
                    }
                }
            }
            
            //随机决定下面要产生的式子是由几个数字构成的
            int s=(int)(Math.random()*(10-2+1)+2);
            
            //随机运算符
            char p[]=new char [s-1];
            for(int i=0;i<s-1;i++)
            {
                symtime=(int)(Math.random()*(3-0+1)+0);
                p[i]=symbollist[symtime];
            }

            //除号后不能有0的存在
            for(int i=0;i<s-1;i++)
            {
                if(p[i]=='/'&&space[time][i+1]==0)
                {
                    flag1=0;
                    break;
                }
            }
            
            if(flag1==1)
            {
                if(boolbracket==1&&s!=2)
                {
                    System.out.print("(");
                }
                
                //若出现连续的除号，则在相应位置输出括号}
                int br1[]=new int [s];
                int br2[]=new int [s];
                for(int i=0;i<s-1;i++)
                {
                    br1[i]=0;
                    br2[i]=0;
                }
                for(int i=1;i<s-1;i++)
                {
                    if(p[i-1]=='/'&&p[i]=='/')
                    {
                        br1[i-1]=1;
                        br2[i]=1;
                    }
                }
                
                //使用栈来完成结果的运算
                Stack<Integer> OPND=new Stack<Integer> ();
                Stack<Character> OPTR=new Stack<Character> ();
                OPTR.push('#');
                
                if(br1[0]==1)
                {
                    System.out.print('(');
                    OPTR.push('(');
                }
                System.out.print(space[time][0]);
                OPND.push(space[time][0]);
                
                for(int i=1;i<s;i++)
                {
                    System.out.print(p[i-1]);
                    if(T.Precede(OPTR.peek(),p[i-1])=='<')
                    {
                        OPTR.push(p[i-1]);
                    }
                    else if(T.Precede(OPTR.peek(),p[i-1])=='>'||T.Precede(OPTR.peek(),p[i-1])=='=')
                    {
                            char c;
                            int a,b;
                            c=OPTR.pop();
                            a=OPND.pop();
                            b=OPND.pop();
                            OPND.push(T.Operate(a, c, b));
                    }
                    else if(T.Precede(OPTR.peek(),p[i-1])=='$')
                    {
                        OPTR.pop();
                    }
                    
                    if(br1[i]==1)
                    {
                        System.out.print('(');
                    }
                    
                    if(space[time][i]<0)
                    {
                        System.out.print('(');
                        System.out.print(space[time][i]);
                        OPND.push(space[time][i]);
                        System.out.print(')');
                    }
                    else
                    {
                        System.out.print(space[time][i]);
                        OPND.push(space[time][i]);
                    }
                    
                    if(br2[i]==1)
                    {
                        System.out.print(')');
                    }
                    
                    if(boolbracket==1&&i==(s-1)/2&&s!=2)
                    {
                        System.out.print(')');
                        if(T.Precede(OPTR.peek(),')')=='<')
                        {
                            OPTR.push(')');
                        }
                        else if(T.Precede(OPTR.peek(),')')=='>'||T.Precede(OPTR.peek(),')')=='=')
                        {
                                char c;
                                int a,b;
                                c=OPTR.pop();
                                a=OPND.pop();
                                b=OPND.pop();
                                OPND.push(T.Operate(a, c, b));
                        }
                        else if(T.Precede(OPTR.peek(),p[i-1])=='$')
                        {
                            OPTR.pop();
                        }
                    }
                }
                
                int realResult=OPND.peek();
                System.out.print("=");
                System.out.print("  请输入您认为正确的结果：");
                int yResult=in.nextInt();
                
                if(yResult==realResult)
                {
                    System.out.println("结果正确");
                    correctNumber++;
                }
                else
                {
                    System.out.println("  结果错误，正确答案为："+realResult);
                }
                
                time++;
            }
        }
        System.out.println("您答对的题数为"+correctNumber);
    }
}

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	设计	设计	分类讨论时出现错误，没考虑完全