icoding测试代码--邻接矩阵

icoding的数据结构并没有一个测试代码，其都是直接编写一个函数的形式，因此很难知道自己的实际输出是什么。针对部分题目，我编写了一系列测试代码以供大家进行数据输出的测试。

请先将你的代码复制

bool matrix_insert_vertex(Graph *G, VertexType v){
    //TODO

}
bool matrix_insert_arc(Graph *G, VertexType v, VertexType w){
   //TODO

}

里面

到函数中然后修改main函数完成测试样例的输入

在main代码中间有个修改提示，请按照提示操作修改即可

icoding使用数字表示顶点集，为了方便，本例用大写字母表示顶点集

部分代码来自白zj老师

main函数中一共有两个区域可以进行修改

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define MAX_VERTEX_NUM 100


typedef int VertexType;
typedef char VertexData; 


typedef enum{
    UNDIFINED=0,DG, UDG
}GraphType;

typedef struct{
    VertexType vertex[MAX_VERTEX_NUM]; //顶点向量
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //邻接矩阵
    int vexnum, arcnum;   //图的当前顶点数和弧数
    GraphType type;      //图的种类标志
}Graph;

void DrawGraph(Graph *G) {
    putchar(' ');
    for (int i = 0; i < G->vexnum; ++i)
        printf("%4c", G->vertex[i]);
    putchar('\n');

    for (int i = 0; i < G->vexnum; ++i) {
        printf("%c", G->vertex[i]);
        for (int j = 0; j < G->vexnum; ++j)
            
                printf("%4d", G->arcs[i][j]);
        putchar('\n');
    }
}
int matrix_locate_vertex(Graph *G, VertexType v) {
    for (int k = 0; k < G->vexnum; ++k)
        if (G->vertex[k] == v)
            return k;

    return -1;
}



bool matrix_insert_vertex(Graph *G, VertexType v){
 //TODO

}
bool matrix_insert_arc(Graph *G, VertexType v, VertexType w){
 //TODO

}


int main(){

    Graph G;
    printf("---icoding---\n6-1|邻接矩阵:\n");
    printf("icoding使用数字表示顶点集，为了方便，本例用大写字母表示顶点集\n");
    printf(">>初始矩阵\n");

//--------------------------您 可 以 修 改 此 框 内 容（可修改区域1/2）---------------------
    int flag=0;
    //可修改，标志位(0:全部测试，1:只测试初始打印，2:只测试初始和插入顶点，3:只测试初始和插入弧)
    G.vexnum = 5;//可修改，顶点数量，顶点从A开始编码，按顺序编。
    G.type = UDG;//可修改，图的类型，DG:有向图 UDG:无向图 要大写哦

    char insert_v = 'F';//等待插入的顶点(适用于第一个函数)

    char insert_a1 = 'F';//等待插入的边的起始点(适用于第二个函数)
    char insert_a2 = 'E';//等待插入的边的终止点(适用于第二个函数)
//--------------------------您 可 以 修 改 此 框 内 容（可修改区域1/2）---------------------



    /*--初始化邻接矩阵--  请勿修改以下内容*/
    for (int k=0; k<G.vexnum;k++)
    {
        G.vertex[k]=k+'A';
    }
    for (int i = 0; i < G.vexnum; ++i) 
        for (int j = 0; j < G.vexnum; ++j)
            G.arcs[i][j] = 0;
    bool vbool=1,abool=1;//不要改，标志位，用于判断插入顶点和插入弧是否成功
    /*--初始化邻接矩阵--  请勿修改以上内容*/


//--------------------------您 可 以 修 改 此 框 内 容（可修改区域2/2）---------------------
    //初始弧，可修改，数字可以代表弧的长度，也可以统一为1，无影响。0代表无边
    //(经在前方初始化了所有边为0，下面只需写有弧的边即可


    G.arcs[0][1] = G.arcs[1][0] = G.arcs[0][2] = G.arcs[2][0] = G.arcs[0][3] = G.arcs[3][0] = G.arcs[0][4] = G.arcs[4][0] = 1;
    G.arcs[1][2] = G.arcs[2][1] = G.arcs[1][3] = G.arcs[3][1] = G.arcs[1][4] = G.arcs[4][1] = 2;
    G.arcs[2][3] = G.arcs[3][2] = G.arcs[2][4] = G.arcs[4][2] = 3;
    G.arcs[3][4] = G.arcs[4][3] = 4;
    //请注意，若为无向图，请保证结构有对称性！包括边的长度和
//--------------------------您 可 以 修 改 此 框 内 容（可修改区域2/2）---------------------


//后续区域请勿修改
//后续区域请勿修改
//后续区域请勿修改

    /*--初始化邻接矩阵：统计弧边数和判断输入内容--  请勿修改以下内容*/
    //遍历邻接矩阵，统计弧的总数
    for (int i=0; i<G.vexnum; i++)
    {
        for (int j=0; j<G.vexnum; j++)
        {
            if (G.arcs[i][j]!=0)
            {
                G.arcnum++;
            }
        }
    }
    if(G.type==UDG)G.arcnum=G.arcnum/2;//无向图，弧数/2
    int init_arcnum = G.arcnum;//初始弧的数量
    //判读输入字母在A-Z内
    if((insert_v<'A'||insert_v>'Z')||(insert_a1<'A'||insert_a1>'Z')||(insert_a2<'A'||insert_a2>'Z'))
    {
        printf("测试样例的输入的顶点或边的字母不在A-Z内！\n");
        printf("请修改main函数中的insert_v和insert_a1和insert_a2的值！\n");
        printf("程序自动终止！\n");
        return 0;
    }
        
    //判断无向图是否满足对称性
    if (G.type==UDG)
    {
        for (int i=0; i<G.vexnum; i++)
        {
            for (int j=0; j<G.vexnum; j++)
            {
                if (G.arcs[i][j]!=G.arcs[j][i])
                {
                    printf("测试样例的输入的无向图不满足对称性！\n");
                    printf("其中异常的一处为G.arcs[%d][%d]与G.arcs[%d][%d]不相等！\n",i,j,j,i);
                    printf("请修改！若您想使用有向图请修改G.type的值为DG\n");
                    printf("程序自动终止！\n");
                    return 0;
                }
            }
        }
    }
    /*--初始化邻接矩阵：统计弧边数和判断输入内容--  请勿修改以上内容*/
    
    

    

   


    

    printf("·初始化信息·    顶点数：%d\t", G.vexnum);
    printf("弧数：%d\t", G.arcnum);
    if(G.type==DG) printf("图的种类标志：有向图\n");
    else if(G.type==UDG) printf("图的种类标志：无向图\n");
    else{
        printf("图的种类标志：错误定义或者未定义！\n程序终止,请修改main函数的内容!\n");
        return 0;
    }
    
    
    DrawGraph(&G);
    printf("\n");

    if(flag==0||flag==2){
    printf(">>插入顶点\n");
    vbool=matrix_insert_vertex(&G, insert_v);

        if(!vbool){
            printf("函数返回：false\n");
        }
        else{
        printf("函数返回：true\n");
        printf("·插入顶点后·    顶点数：%d\t", G.vexnum);
        printf("弧数：%d\t", G.arcnum);
            if(G.type==DG) printf("图的种类标志：有向图\n");
            else if(G.type==UDG) printf("图的种类标志：无向图\n");
            else{
                printf("图的种类标志：错误定义或者未定义！\n程序终止,请修改main函数的内容!\n");
                return 0;
        }


        DrawGraph(&G);
        }
    printf("\n");
    }
    else{
        printf("您未测试插入顶点，若需要请修改main函数的flag\n\n");
    }



    if(flag==0||flag==3){
    printf(">>插入边\n");
    abool=matrix_insert_arc(&G,insert_a1,insert_a2);


    if(!abool){
        printf("函数返回：false\n");
    }
    else{
        printf("函数返回：true\n");
        printf("·插入边后·      顶点数：%d\t", G.vexnum);
        printf("弧数：%d\t", G.arcnum);
        if(G.type==DG) printf("图的种类标志：有向图\n");
        else if(G.type==UDG) printf("图的种类标志：无向图\n");
        else{
            printf("图的种类标志：错误定义或者未定义！\n程序终止,请修改main函数的内容!\n");
            return 0;
        }

        if(G.type==UDG&&G.vexnum==init_arcnum+2){
            printf("注意:无向图的边只算矩阵的上三角或下三角非0个数，不是整个哦，所以边的个数不是加2\n");
        }

        DrawGraph(&G);
    }
    printf("\n");
    }
    else{
        printf("您未测试插入边，若需要请修改main函数的flag\n\n");
    }
    if(!abool&&flag==3){
        printf("--\nmatrix_insert_arc函数返回false的原因可能是未运行插入顶点操作，导致图中找不到边的一个顶点\n您需要修改main函数中的flag值来运行插入顶点的函数。\n--\n");
    }
    printf("\n\n---测试结束---\n");
    


    
    return 0;
}

如果不对main函数进行任何修改

其正确的输出结果如下图