软件工程（2019）结对编程第一次作业

最新推荐文章于 2020-12-03 22:23:08 发布

weixin_30629977

最新推荐文章于 2020-12-03 22:23:08 发布

阅读量173

点赞数

文章标签：开发工具操作系统内存管理

原文链接：http://www.cnblogs.com/wyd76/p/10759326.html

版权

一、作业说明

结对伙伴：李振飞

李振飞代码地址

李振飞博客地址

二、代码复审

1.代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

typedef float WeightType;//定义权重的类型
#define MaxVertexNum 50
#define MaxStringNum 15


//创建查找表定义
typedef struct tablenode {
    int Nv;
    char table[MaxVertexNum][MaxStringNum];
}TABLE, *PtrTotable;
void InitTALE(PtrTotable PT) {/* 初始化查找表 */
    int i;
    for (i = 0; i < MaxVertexNum; i++)
        PT->table[i][0] = '\0';
    PT->Nv = 0;
}
int FindTALE(PtrTotable PT, char * Target) {
    int i;
    for (i = 0; i < PT->Nv; i++)
        if (strcmp(PT->table[i], Target) == 0)
            return i;/* 找到返回序号 */
    return -1;/* 未找到标志 */
}
int InsertTALE(PtrTotable PT, char * Ins) {
    strcpy_s(PT->table[PT->Nv], MaxStringNum - 1, Ins);
    return PT->Nv++;
}
//结束查找表定义

//创建图的邻接表定义
typedef int Vertex;         // 用顶点下标表示顶点,为整型
/* 边的定义 */
struct ENode {
    Vertex V1, V2;      
    WeightType Weight;  /* 权重 */
};
typedef struct ENode *PtrToENode;
typedef PtrToENode Edge; /* 邻接点的定义 */

typedef struct AdjVNode *PtrToAdjVNode;

struct AdjVNode {
    Vertex AdjV;        
    WeightType Weight;  /* 边权重 */
    PtrToAdjVNode Next;    /* 指向下一个邻接点的指针 */
};
/* 顶点表头结点的定义 */
typedef struct Vnode {
    PtrToAdjVNode FirstEdge;/* 边表头指针 */
} AdjList[MaxVertexNum];
/* 图结点的定义 */
struct GNode {
    int Nv;     
    int Ne;     
    AdjList G;  /* 邻接表 */
};
typedef struct GNode *PtrToGNode;
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
LGraph CreateGraph(int VertexNum) {
    // 初始化一个有VertexNum个顶点但没有边的图
    Vertex V;
    LGraph Graph;
    Graph = (LGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;     /* 初始化邻接表头指针 */
    for (V = 0; V < Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
    return Graph;
}
void InsertEdge(LGraph Graph, Edge E) {
    PtrToAdjVNode NewNode;          /* 插入边 <V1, V2> */
    /* 为V2建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    /* 将V2插入V1的表头 */
    NewNode->Next = Graph->G[E->V1].FirstEdge;//永远插在链表头的位置
    Graph->G[E->V1].FirstEdge = NewNode;
    /* 无向图，还要插入边 <V2, V1> */
    /* 为V1建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;     /* 将V1插入V2的表头 */
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}
LGraph BuildGraph(PtrTotable & tab, char * file) {
    FILE * fp;
    errno_t err;
    LGraph Graph;
    Edge E;
    char V1[MaxStringNum];
    char V2[MaxStringNum];
    int Nv, i, tmp = 0;
    err = fopen_s(&fp, file, "r");
    if (err == 0)
    {
        tab = (PtrTotable)malloc(sizeof(TABLE));
        InitTALE(tab);
        fscanf_s(fp, "%d", &Nv);   /* 读入顶点个数 */
        getc(fp);
        Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
        fscanf_s(fp, "%d", &(Graph->Ne));/* 读入边数 */
        getc(fp);
        if (Graph->Ne != 0) { /* 如果有边 */
            E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
            /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
            for (i = 0; i < Graph->Ne; i++) {
                fscanf_s(fp, "%s %s %f", V1, MaxStringNum - 1, V2, MaxStringNum - 1, &E->Weight);/*不用getchar的话，可能造成读取字符错误*/
                getc(fp);
                if ((tmp = FindTALE(tab, V1)) && (tmp == -1))
                    E->V1 = InsertTALE(tab, V1);
                else
                    E->V1 = tmp;
                if ((tmp = FindTALE(tab, V2)) && (tmp == -1))
                    E->V2 = InsertTALE(tab, V2);
                else
                    E->V2 = tmp;
                InsertEdge(Graph, E);
            }
        }
        fclose(fp);
    }
    else
        Graph = NULL;
    return Graph;
}
//创建图定义结束





//遍历最小生成树定义开始
void PrifMinSpanTree(const LGraph Graph, const PtrTotable PT, const float totalweight) {
    int i;
    PtrToAdjVNode NEXT = NULL;
    printf("****************************************************\n");
    printf("*    总费用为：%-15.2f                     *\n", totalweight);
    printf("*    公路网最经济的方案如下：                      *\n");

    for (i = 0; i < Graph->Nv; i++)
        if (Graph->G[i].FirstEdge != NULL)
            for (NEXT = Graph->G[i].FirstEdge; NEXT != NULL; NEXT = NEXT->Next)
                if (i < NEXT->AdjV)
                    printf("*    %-14s%-14s%-15.2f   *\n", PT->table[i], PT->table[NEXT->AdjV], NEXT->Weight);
    printf("****************************************************\n");
}
//遍历最小生成树定义结束





//顶点并查集定义
typedef Vertex ElementType;
typedef Vertex SetName;
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */

void InitializeVSet(SetType S, int N) { /* 初始化并查集 */
    ElementType X;
    for (X = 0; X < N; X++)
        S[X] = -1;
}
void Union(SetType S, SetName Root1, SetName Root2) {
    /* 这里前提条件是Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if (S[Root2] < S[Root1]) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {
        /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}
SetName Find(SetType S, ElementType X) {
    /* 默认集合元素全部初始化为-1 */
    if (S[X] < 0) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find(S, S[X]);
}
bool CheckCycle(SetType VSet, Vertex V1, Vertex V2) {
    /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;
    Root1 = Find(VSet, V1); /* 得到V1名称 */
    Root2 = Find(VSet, V2); /* 得到V2名称 */
    if (Root1 == Root2) /* 若V1和V2连通 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union(VSet, Root1, Root2);
        return true;
    }
}
//并查集定义结束


//最小堆定义
void Swap(ENode * left, ENode * right) {
    ENode tmp;
    tmp = *right;
    *right = *left;
    *left = tmp;
}

void PercDown(Edge ESet, int p, int N) {
    /* 将N个元素的边数组中以ESet[p]为根的子堆调整为最小堆 */
    int Parent, Child;
    struct ENode X;
    X = ESet[p]; /* 取出根结点存放的值 */
    for (Parent = p; (Parent * 2 + 1) < N; Parent = Child) {
        Child = Parent * 2 + 1;/*左节点，应该是从0数组开始存储的*/
        if ((Child != N - 1) && (ESet[Child].Weight > ESet[Child + 1].Weight))
            Child++;  /* Child指向左右子结点的较小者 */
        if (X.Weight <= ESet[Child].Weight)
            break; /* 找到了合适位置 */
        else
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}
void InitializeESet(LGraph Graph, Edge ESet) {
    /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;    /* 将图的边存入数组ESet */
    ECount = 0;
    for (V = 0; V < Graph->Nv; V++)
        for (W = Graph->G[V].FirstEdge; W; W = W->Next)
            if (V < W->AdjV) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;/*先做运算，后自增*/
            }
    /* 初始化为最小堆 */
    for (ECount = Graph->Ne / 2; ECount >= 0; ECount--)/*总边数除以2一定落在上一层，可以证明*/
        PercDown(ESet, ECount, Graph->Ne);
}
int GetEdge(Edge ESet, int CurrentSize) { /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */
    Swap(&ESet[0], &ESet[CurrentSize - 1]);/* 将剩下的边继续调整成最小堆 */
    PercDown(ESet, 0, CurrentSize - 1);
    return CurrentSize - 1; /* 返回最小边所在位置 */
}
//最小堆定义结束


bool InputLegalityTest(LGraph Graph, const PtrTotable tab) {
    /*用于检查是不是有重复边的输入*/
    int i;
    PtrToAdjVNode NEXT = NULL;
    for (i = 0; i < Graph->Nv; i++)
    {
        SetType VSET;
        InitializeVSet(VSET, Graph->Nv);/* 初始化并查集 */
        for (NEXT = Graph->G[i].FirstEdge; NEXT != NULL; NEXT = NEXT->Next)
        {
            if (CheckCycle(VSET, i, NEXT->AdjV) == false)
            {
                printf("有重复边的输入：%-14s%-14s%-13.2f\a\n\n", tab->table[i], tab->table[NEXT->AdjV], NEXT->Weight);
                return false;
            }
            if (NEXT->Weight < 0)
            {
                printf("有非法输入！\n请检查输入的数据：%-14s%-14s%-13.2f\a\n\n", tab->table[i], tab->table[NEXT->AdjV], NEXT->Weight);
                return false;
            }
        }
    }
    return 1;/* 没有错误*/
}


WeightType Kruskal(LGraph Graph, LGraph & MST) { /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */
    InitializeVSet(VSet, Graph->Nv); /* 初始化顶点并查集 */
    ESet = (Edge)malloc(sizeof(struct ENode)*Graph->Ne);
    InitializeESet(Graph, ESet); /* 初始化边的最小堆 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 权重和 */
    ECount = 0;      /* 记录收录的边数 */
    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while (ECount < Graph->Nv - 1) {
        NextEdge = GetEdge(ESet, NextEdge); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        if (CheckCycle(VSet, ESet[NextEdge].V1, ESet[NextEdge].V2) == true) {/* 将该边插入MST */
            InsertEdge(MST, ESet + NextEdge);
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++;
        }
    }
    if (ECount < Graph->Nv - 1)
        TotalWeight = -1; /* 生成树不存在 */
    return TotalWeight;
}

int main() {
    float weight;
    LGraph mygraph, mst = NULL;
    PtrTotable PT = NULL;
    char file[50];/* 定义一个字符数组 */
    while ((printf("请输入正确文件名称，回车结束。文件不存在则退出！\n")) && (gets_s(file, 49))) {
        mygraph = BuildGraph(PT, file);
        if (mygraph == NULL)
            break;
        if (InputLegalityTest(mygraph, PT) == false) {
            continue;
        }
        weight = Kruskal(mygraph, mst);
        if (weight < 0) /* 图不联通 */
            printf("输入交通图不连通，请检查数据\a\n\n");
        else
            PrifMinSpanTree(mst, PT, weight);/* 输出最小生成树 */
        continue;
    }
    return 1;
}

2.审查表

项目名称	求一个图的最小联通路径
审查人	王艳东	审查日期	2019/4/24
代码名称	source.cpp	代码作者	李振飞
文件结构
序号	审查项目	重要性	结论	备注
1	头文件和定义文件的名称是否合理？		是
2	头文件和定义文件的目录结构是否合理？		是
3	版权和版本声明是否完整？		是
4	头文件是否使用了 ifndef/define/endif 预处理块?	重要	是
5	头文件中是否只存放“声明”而不存放“定义”？		否
程序版式
序号	审查项目	重要性	结论	备注
6	代码段间的空行是否得体？		否	有些地方空行过多
7	代码行内的空格是否得体？		是
8	长行拆分是否得体？		是
9	“{” 和 “}” 是否各占一行并且对齐于同一列？		否
10	一行代码是否只做一件事？如只定义一个变量，只写一条语句。	重要	否
11	If、for、while、do等语句自占一行，不论执行语句多少都要加 “{}”。	重要	否	有些地方简短语句未加括号
12	在定义变量（或参数）时，是否将修饰符 * 和＆紧靠变量名？	重要	是
13	注释是否清晰并且必要？	重要	是
14	注释是否没有错误且不会导致误解？	重要	否
15	类结构的public, protected, private顺序是否在所有的程序中保持一致？	重要		未涉及类
命名规则
序号	审查项目	重要性	结论	备注
16	命名规则是否与所采用的操作系统或开发工具的风格保持一致？	重要	是
17	标识符是否直观且可以拼读？		是
18	标识符的长度应当符合“min-length && max-information”原则？		是
19	程序中是否出现相同的局部变量和全部变量？	重要	是	count不同模块出现相同的局部变量，对程序无影响
20	类名、函数名、变量和参数、常量的书写格式是否遵循一定的规则？		是
21	静态变量、全局变量、类的成员变量是否加前缀？		否
表达式与基本语句
序号	审查项目	重要性	结论	备注
22	如果代码行中的运算符比较多，是否已经用括号清楚地确定表达式的操作顺	重要	是
23	是否编写太复杂或者多用途的复合表达式？		否
24	是否将复合表达式与“真正的数学表达式”混淆？	重要	否
25	是否用正确的方式写if语句? 例如	重要
	1) 将布尔变量直接与TRUE、FALSE或者1、0进行比较。		否
	2) 将浮点变量用“==”或“！=”与任何数字比较。		否
	3) 将指针变量用“==”或“！=”与NULL比较。		否
26	如果循环体内存在逻辑判断，并且循环次数很大，是否已经将逻辑判断移到循环体外面？		否	比较字符串大小时直接在循环体内进行了
27	Case语句的结尾是加了break？	重要	否	未涉及switch语句
28	是否写了switch的default分支？	重要	否	未涉及switch语句
29	使用goto 语句时是否留下隐患? 例如跳过了某些对象的构造、变量的初始化，重要的计算等。	重要	否	未涉及goto语句
常量
序号	审查项目	重要性	结论	备注
30	是否使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串？		是
31	是否误解了类中的const数据成员？因为const数据成员只在某个对象		否	未涉及类
32	如果某一常量与其它常量密切相关，是否在定义中包含了这种关系？	重要	是
33	生存期内是常量，而对于整个类而言却是可变的。		是
函数设计
序号	审查项目	重要性	结论	备注
34	参数的书写是否完整？不要贪图省事只写参数的类型而省略参数名字。		是
35	参数命名、顺序是否合理？		是
36	参数的个数是否太多？		否
37	是否使用类型和数目不确定的参数？		否
38	是否省略了函数返回值的类型？		否
39	函数名字与返回值类型在语义上是否冲突？		否
40	是否将正常值和错误标志混在一起返回？正常值应当用输出参数获得，而错误标志用return语句返回。	重要	否	有些地方未做错误处理
41	在函数体的“入口处”，是否用assert对参数的有效性进行检查？	重要	否
42	使用滥用了assert？例如混淆非法情况与错误情况，后者是必然存在的并且	重要	否	t
43	return语句是否返回指向“栈内存”的“指针”或者“引用”？	重要	否
44	是否使用const提高函数的健壮性？const可以强制保护函数的参数、返回值，甚至函数的定义体。“Use const whenever you need”		否
内存管理
序号	审查项目	重要性	结论	备注
45	用malloc或new申请内存之后，是否立即检查指针值是否为NULL？	重要	否	未检查指针值是否为NULL
46	是否忘记为数组和动态内存赋初值？	重要	是
47	数组或指针的下标是否越界？	重要	否
48	动态内存的申请与释放是否配对？	重要	否	只申请了并没有释放
49	是否有效地处理了“内存耗尽”问题？	重要	否
50	是否修改“指向常量的指针”的内容？	重要	否
51	是否出现野指针？例如	重要
	1) 指针变量没有被初始化	重要	是
	2) 用free或delete释放了内存之后，忘记将指针设置为NULL。		否
52	是否将malloc/free 和 new/delete 混淆使用？	重要	否
53	malloc语句是否正确无误？例如字节数是否正确？类型转换是否正确？	重要	是
54	在创建与释放动态对象数组时，new/delete的语句是否正确无误？	重要	否
其它常见问题
序号	审查项目	重要性	结论	备注
55	数据类型问题：	重要
	1) 变量的数据类型有错误吗？		否
	2) 存在不同数据类型的赋值吗？		否
	3) 存在不同数据类型的比较吗？		否
56	变量值问题：	重要
	1) 变量的初始化或缺省值有错误吗？		否
	2) 变量发生上溢或下溢吗？		否
	3) 变量的精度够吗?		是	因为程序较小，所以精度不高
57	逻辑判断问题：	重要
	1) 由于精度原因导致比较无效吗？		否
	2) 表达式中的优先级有误吗？		否
	3) 逻辑判断结果颠倒吗？		否
58	循环问题：	重要
	1) 循环终止条件不正确吗？		否
	2) 无法正常终止（死循环）吗？		否
	3) 错误地修改循环变量吗？		否
	4) 存在误差累积吗？		否
59	错误处理问题：	重要
	1) 忘记进行错误处理吗？		是
	2) 错误处理程序块一直没有机会被运行？		否
	3) 错误处理程序块本身就有毛病吗？		否
	4) 错误处理程序块是“马后炮”吗？如在被它被调用之前软件已经出错。		否
60	文件I/O问题：	重要
	1) 对不存在的或者错误的文件进行操作吗？		未涉及
	2) 文件以不正确的方式打开吗？		未涉及
	3) 文件结束判断不正确吗？		未涉及
	4) 没有正确地关闭文件吗?		未涉及

三、评价

对于李振飞的代码，我仔细的复审之后，做出如下几点评价：

1.优点：

 + 函数使用得当，并且将代码分成多个功能模块，使读者和自己都能够很清晰的理解代码功能含义
    每个功能模块的实现也很简单明了，让人很容易读懂
 + 注释简洁准确，在每个将要实现的功能模块前都留有注释，给人一种清晰感，而且在比较复杂的
    运算符或者语句后都会有相应的解释，这点做得很好
 + 命名非常得体，在各个功能函数的命名都准确的表达该功能模块的作用，而且命名符合驼峰式命
    名规则，并没有混乱的命名
 + 整体逻辑清晰，代码中未出现导致程序不正常终止的错误逻辑，而且运行时提示很到位，也有专门
    的输出函数，给出各种提示信息，main函数里只写了调用各个函数的一个主体，并没有太多的函数
    功能实现，这会让函数的可维护性更强
 + 错误处理到位，在用户输入非法字符或者进行错误操作时，都会有相应的错误提示和错误处理

2.缺点：

 + 括号使用不得当，括号的开始和结尾未对齐，读着十分不方便，还有一些简单if语句后没有加括号，
    这对以后程序的维护带来很多不便。
 + 变量常量的定义不合理，在C语言中都习惯将一些常量变量定义在最前面，但是代码中出现了随用随
    定义的现象，这个很不合理。

转载于:https://www.cnblogs.com/wyd76/p/10759326.html

weixin_30629977

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
软件工程（2019）结对编程第一次作业

一、作业说明结对伙伴：李振飞李振飞代码地址李振飞博客地址二、代码复审1.代码#include <stdio.h>#include <stdlib.h>#include <string.h>#include <math.h>typedef float WeightType;//定义权重的类型#define MaxVe...
复制链接

扫一扫