结对项目——四则运算题目生成器

一、GitHub项目地址 :

https://github.com/OurPrograming/Exercises

结对项目成员：软三 陈纪禧（3118005043）、软三 程伟杰（3118005045）

二、PSP预计时间:

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	60
· Estimate	· 估计这个任务需要多少时间	60
Development	开发	1680
· Analysis	· 需求分析 (包括学习新技术)	120
· Design Spec	· 生成设计文档	30
· Design Review	· 设计复审 (和同事审核设计文档)	10
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	20
· Design	· 具体设计	120
· Coding	· 具体编码	1200
· Code Review	· 代码复审	60
· Test	· 测试（自我测试，修改代码，提交修改）	120
Reporting	报告	150
· Test Report	· 测试报告	60
· Size Measurement	· 计算工作量	30
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	60
合计		1890

 

三、效能分析:

 

 分析：由效能分析易知，判重函数占用程序时间最多，后续优化可从这方面入手。

四、设计实现过程:

结构设计：

        设计6个类，不同类实现不同功能，说明如下：

                                                          Parameter  //处理命令行中传来的参数

                                                          Generate    //生成表达式

                                                          Statistics    //统计类，对于给定题目答案的对错进行统计

                                                          BinaryTree //二叉树类

                                                          Calculator  //计算类

                                                          Fraction     //分数类，所有运算数都是此类型

类与函数的调用关系图：（注：调用→被调用）

五、部分关键代码设计与说明:

Parameter  //处理命令行中传来的参数

表达式查重：

void Parameter::generateExercises(int num, int range)
{
    if (num == 0 || range == 0)
        return;
    
    //打开文件
    exercises.open("Exercises.txt", std::ios::out | std::ios::trunc);
    answers.open("Answers.txt", std::ios::out | std::ios::trunc);
    if (!exercises.is_open() || !answers.is_open())
        return;
    
    //每生成一个表达式都与其他元素比较，不重复就入组
    vector<BinaryTreeNode *> exe;            //用于存放表达式树
    exe.reserve(num);                        //预留空间避免过多扩容

    vector<BinaryTreeNode *>::iterator ite;
    Generate *generate = generate = new Generate(range);
    BinaryTree *tree = nullptr;
    bool flag = false;                    //标志是否重复

    for (int i = 0; i < num; i++)            //生成num个
    {
        do
        {
            tree = generate->genExercise();
            for (ite = exe.begin(); ite != exe.end(); ite++)
            {
                flag = BinaryTree::compare(tree->pRoot, *ite);
                if (flag == true)        //匹配到重复就跳出判断，避免标志被更改
                {
                    //重复就删除生成的树
                    delete tree;
                    tree = nullptr;
                    break;
                }
            }            
        } while (flag == true);

        if (flag == false)        //未重复就push
        {
            exe.push_back(tree->pRoot);
        }
    }

    for (int i = 0; i < (int)exe.size(); i++)
    {
        string strExercises = generate->getExercise(exe.at(i));
        exercises << i + 1 << "." << strExercises.c_str() << endl;
        
        //转成计算器计算结果避免出错
        BinaryTreeNode *result = Calculator::toTree(Calculator::toReversePolish(strExercises));
        string strAnswers = Calculator::calcResult(result).display();
        answers << i + 1 << "." << strAnswers.c_str() << endl;
    }

    cout << "题目与答案已写入到文件" << endl;

    delete generate;
    //关闭文件
    exercises.close();
    answers.close();
}

Generate类    //生成表达式

表达式建树：

BinaryTree * Generate::genExercise()
{
    //3 --> 2 --> 2
    //     -> 3 --> 1
    
    //运算符个数
    std::uniform_int_distribution<int> opeCount(1, 3);
    int opeNum = opeCount(mt);

    //先新建出一颗最小树
    BinaryTreeNode *left = new BinaryTreeNode(getFraction().display());
    BinaryTreeNode *right = new BinaryTreeNode(getFraction().display());
    string *data = new string(1, getOperator());
    BinaryTreeNode *root = new BinaryTreeNode(*data, left, right);
    standardization(root);
    opeNum--;

    if (opeNum == 0)        //如果运算符只有一个直接返回
    {
        BinaryTree *tree = new BinaryTree(root);
        return tree;
    }

    //用于二选一的随机数
    std::uniform_int_distribution<int> randBool(0, 1);

    //选择下一步是2或3
    if (randBool(mt) == 0 && opeNum == 2)    //再生成一个最小树并连接
    {
        left = new BinaryTreeNode(getFraction().display());
        right = new BinaryTreeNode(getFraction().display());
        data = new string(1, getOperator());
        BinaryTreeNode *tempRoot = new BinaryTreeNode(*data, left, right);
        standardization(tempRoot);
        opeNum--;

        //选择左右顺序
        if (randBool(mt) == 0)    //新树在左
        {
            left = tempRoot;
            right = root;
        }
        else
        {
            left = root;
            right = tempRoot;
        }
        //连接
        data = new string(1, getOperator());
        root = new BinaryTreeNode(*data, left, right);
        standardization(root);
        opeNum--;

        BinaryTree *tree = new BinaryTree(root);
        return tree;
    }
    else        //往上插
    {
        do
        {    
            //二选一 左上or右上
            if (randBool(mt) == 0)    //左上
            {
                left = new BinaryTreeNode(getFraction().display());
                right = root;
            }
            else            //右上
            {
                left = root;
                right = new BinaryTreeNode(getFraction().display());
            }
            data = new string(1, getOperator());
            root = new BinaryTreeNode(*data, left, right);
            standardization(root);
            opeNum--;
        } while (opeNum > 0);

        BinaryTree *tree = new BinaryTree(root);
        return tree;
    }
    return nullptr;
}

 表达式加括号：

bool Generate::toString(BinaryTreeNode * root, string &strExercise)
{
    if (root == nullptr)
    {
        return true;
    }

    bool lChildBracket = false, rChildBracket = false;            //标志括号
    int leftPriority = 0, curPriority = 0, rightPriority = 0;    //优先级

    //中序遍历
    if (root->leftChild != nullptr)
    {
        //左子树是操作符加括号
        if (Calculator::isOperator(root->leftChild->data.at(0)))
        {
            //得到优先级
            leftPriority = Calculator::getPriority(root->leftChild->data.at(0));
            curPriority = Calculator::getPriority(root->data.at(0));
            if (leftPriority == 0 || curPriority == 0)
            {
                return false;
            }
            if (curPriority > leftPriority)        //优先级大加括号
            {
                strExercise = strExercise +  "(";
                lChildBracket = true;
            }
        }
        //遍历左子树
        toString(root->leftChild, strExercise);
        //补上括号
        if (lChildBracket == true)
        {
            strExercise = strExercise + ")";
            lChildBracket = false;
        }
    }

    //中
    if (Calculator::isOperator(root->data.at(0)))
        strExercise = strExercise + " " + root->data + " ";
    else
        strExercise = strExercise + root->data;

    //右
    if (root->rightChild != nullptr)
    {
        //右子树是操作符加括号
        if (Calculator::isOperator(root->rightChild->data.at(0)))
        {
            //得到优先级
            rightPriority = Calculator::getPriority(root->rightChild->data.at(0));
            curPriority = Calculator::getPriority(root->data.at(0));
            if (rightPriority == 0 || curPriority == 0)
            {
                return false;
            }
            if (curPriority > rightPriority)        //优先级大加括号
            {
                strExercise = strExercise + "(";
                rChildBracket = true;
            }
        }
        //遍历右子树
        toString(root->rightChild, strExercise);
        //补上括号
        if (rChildBracket == true)
        {
            strExercise = strExercise + ")";
            rChildBracket = false;
        }
    }
    return true;
}

 Calculator  //计算类

传入中缀表达式转为逆波兰式:

string Calculator::toReversePolish(string expression)  //传入中缀表达式转为逆波兰式
{
    std::stack<string> S1;  //运算符栈
    std::stack<string> S2;  //逆波兰式栈
    string *ope;     //运算符,分数
    string *exp = new string;  //逆波兰式
    string *leftbracket = new string(1, '(');    //左括号

    for (int i = 0; i < expression.length(); i++)  //从expression中逐个取出字符
    {
        if (isOperator(expression.at(i)))  //若取出运算符
        {
            if (S1.empty() || expression.at(i) == '(')
            {
                ope = new string(1, expression.at(i));
                S1.push(*ope);   
            }
            else if(expression.at(i) == ')')
            {
                ope = new string;
                *ope = S1.top();   S1.pop();
                while ((*ope).at(0) != '(')  //取出'('后停止循环，并抛弃'('
                {
                    if ((*ope).at(0) != '(')
                    {
                        S2.push(*ope);
                    }
                    ope = new string;
                    *ope = S1.top();   S1.pop();
                }
                i++;
            }
            else if (getPriority(expression.at(i)) > getPriority(S1.top().at(0)))  //比较优先级
            {
                ope = new string(1, expression.at(i));
                S1.push(*ope);  //该运算符优先级比栈顶运算符优先级高，直接入栈
            }
            else
            {
                if (!S1.empty())
                {
                    while (getPriority(expression.at(i)) <= getPriority(S1.top().at(0)))
                    {   //从运算符栈S1逐个取出运算符并压入表达式栈S2，直到该运算符优先级比栈顶运算符优先级高
                        ope = new string;
                        *ope = S1.top();   S1.pop();
                        S2.push(*ope);
                        if (S1.empty()) break;
                    }
                }
                ope = new string(1, expression.at(i));
                S1.push(*ope);   //完成操作后该运算符优先级比栈顶运算符优先级高，入运算符栈S1
            }
        }
        else
        { 
            if (expression.at(i) == ' ')  i++;  //隔离第一个空格
            string fat;
            while (expression.at(i) != ' ' && expression.at(i) != '(' && expression.at(i) != ')')
            {   //保存分数字符串
                fat.push_back(expression.at(i));
                i++;
                if (i >= expression.length()) break;
            }
            if (!fat.empty())
            {
                S2.push(fat);    //生成分数字符串，并压入表达式栈S2
            }
            if (i < expression.length())
            {
                if (expression.at(i) == '(' || expression.at(i) == ')')  i--;
            }
        }
    }
    while (!S2.empty())   //将表达式栈逆序
    {
        string op;
        op = S2.top();   S2.pop();
        S1.push(op);
    }
    exp = new string;
    while(!S1.empty())  //组装逆波兰式
    {
        string str = S1.top();  S1.pop();
        if (!S1.empty())
        {
            *exp = *exp + str + ' ';
        }
        else
        {
            *exp = *exp + str;
        }
    }
    return *exp;  //返回逆波兰式
}

逆波兰式转为树:

BinaryTreeNode * Calculator::toTree(string exp)  //逆波兰式转为树
{
    std::stack<BinaryTreeNode*> num;    //数字栈
    BinaryTreeNode *exp_ptr = nullptr;  //结点指针
    BinaryTreeNode *right = nullptr;    //右孩子指针
    BinaryTreeNode *left = nullptr;     //左孩子指针
    string *data_exp;         //结点数据

    for (int i = 0; i < exp.length(); i++)  //逐个字符读取逆波兰式
    {
        if (isOperator(exp.at(i)))     //读取到运算符
        {
            right = num.top();  num.pop(); 
            left = num.top();  num.pop();
            data_exp = new string(1,exp.at(i));     //将运算符转化为string类型，并赋给结点数据data

            BinaryTreeNode *exp_root = new BinaryTreeNode(*data_exp, left, right);  //构建新树
            num.push(exp_root);  
        }
        else
        {   //读取到数字，生成完整分数字符串，并压入数字栈num
            if (exp.at(i) == ' ')   i++;   //隔离第一个空格
            if (!isOperator(exp.at(i)))
            {
                string fat;
                while (exp.at(i) != ' ')
                {   //保存分数字符串
                    fat.push_back(exp.at(i));
                    i++;
                    if (i >= exp.length()) break;
                }
                exp_ptr = new BinaryTreeNode;
                if (!fat.empty())
                {
                    exp_ptr->data = fat;
                    num.push(exp_ptr);
                }
            }
            else
            {
                i--;
            }
        }
    }
    exp_ptr = num.top();  num.pop();  //从栈顶取出建好的树的根结点
    return exp_ptr;   //返回树的根结点
}

六、测试运行:

1.生成一万道题目与答案：

 

2.批改一万道题目：

 

 3.修改1，4，6题的答案再次批改：

 

       

七、完整PSP:

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	60	90
· Estimate	· 估计这个任务需要多少时间	60	90
Development	开发	1680	1600
· Analysis	· 需求分析 (包括学习新技术)	120	160
· Design Spec	· 生成设计文档	30	30
· Design Review	· 设计复审 (和同事审核设计文档)	10	10
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	20	20
· Design	· 具体设计	120	120
· Coding	· 具体编码	1200	1080
· Code Review	· 代码复审	60	60
· Test	· 测试（自我测试，修改代码，提交修改）	120	120
Reporting	报告	150	120
· Test Report	· 测试报告	60	30
· Size Measurement	· 计算工作量	30	30
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	60	60
合计		1890	1810

八、项目小结:

开发初：

本来我们想使用VS上的插件live share进行结对项目的开发，但后面发现这个插件不符合我们的想法，后转用Github团队仓库进行开发。

遇到的一大困难是对Github团队仓库的使用，仔细研究之后才初步学会使用，了解了分支、更改、同步、拉取、推送等功能，解决难题后也算是一大收获。

项目本身：

由于我们两人编程水平相差较大，纪禧很强而伟杰只有c语言基础，开发过程比较坎坷。后来也是通过不断交流，不断翻阅博客，终于实现了这个项目。

优点：前期结构框架定得很好，所以后续实现和改动比较方便。

难点：中缀表达式转逆波兰式建树的过程中需要考虑的因素很多，对各种情况的判断及解决比较复杂，刚写好时总是出现越界问题，后用断点不断调试，终于改好。

结对感受：

合作比单人更有动力，交流更多，犯错更少，学到的东西也更多，更迅速。