icoding测试代码--邻接表1

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

请先将你的代码复制到

bool insert_vertex(ListGraph *G, VertexType v){
//TODO
}
bool insert_arc(ListGraph *G, VertexType v, VertexType w){
//TODO
}

函数中

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

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

无需在意下方定义的InfoPtr *info ，icoding对此不检测，我们的测试代码也没有对其的打印输出

typedef struct ArcNode
{
    int adjvex;
    InfoPtr *info;
    struct ArcNode *nextarc;

}ArcNode;

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

部分代码来自白zj老师

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

typedef char VertexType;
typedef enum{
    UNDEFINED,DG, UDG
}GraphType;

typedef struct ArcNode
{
    int adjvex;
    //InfoPtr *info;这个icoding没看，我也不知道啥意思
    struct ArcNode *nextarc;

}ArcNode;

typedef struct VNode
{
    VertexType data;
    ArcNode *firstarc;
}VNode;
typedef struct
{
    VNode vertex[MAX_VERTEX_NUM];
    int vexnum, arcnum;
    GraphType type;
}ListGraph;

int locate_vertex(ListGraph *G, VertexType v) {
    for (int k = 0; k < G->vexnum; ++k)
        if (G->vertex[k].data == v)
            return k;

    return -1;
}

void DrawGraph(ListGraph *G) {
    ArcNode *p;

    for (int i = 0; i < G->vexnum; ++i) {
        printf("%2d |%2c : ", i, G->vertex[i].data); //表头结点
        p = G->vertex[i].firstarc;
        if (p == NULL)
            printf("^");
        else
            while (p != NULL) {
                printf("--> %d(%c) ", p->adjvex, G->vertex[p->adjvex].data); //外表结点
                p = p->nextarc;                                              //外表结点下移
            }
        putchar('\n');
    }
}


bool insert_vertex(ListGraph *G, VertexType v){
   //TODO
}


bool insert_arc(ListGraph *G, VertexType v, VertexType w){
  //TODO
}





int main() {

    ListGraph G;
//----------以 下 内 容 请 根 据 提 示 修 改-----------------
    G.type = UDG;//可修改，图的种类，DG：有向图，UDG 无向图
    G.vexnum = 4;//可修改,顶点集个数，从A开始编号。

    VertexType insert_ver='F';//可修改，表示插入顶点的标号
    VertexType insert_arc_v1='A', insert_arc_v2='D';//可修改，表示插入边的起点和终点的标号
    int flag=0;
    //可修改，标志位(0:全部测试，1:只测试初始打印，2:只测试初始和插入顶点，3:只测试初始和插入弧)

    VertexType arc1[]={'A','B','A','C','B'};
    VertexType arc2[]={'A','A','B','B','C'};
        //以上两个数组代表初始化时边的起点和终点标号，且保持上下对应关系。
        //示例一：输入比如arc1[]={'A'} arc2[]={'B'} 代表在图中有A-->B边
        //示例二：输入比如arc1[]={'A','B'} arc2[]={'B','B'} 代表在图中有A-->B,B-->B边
        //请保证没有重复边（否则会导致边数计算错误）；
        //保证输入的边的起点和终点都在图中存在；
        //保证起点和终点的顶点集个数相同，环请写成示例二的格式（终点和起点都是一样的字母）。
        //输入的边的起点和终点都是大写字母，用单引号引起，不是数字。
        //对于无向图，必须保证对称性，即既有A-->B，也有B-->A。
        //对于有向图，可以不保证对称性。
//----------以 上 内 容 请 根 据 提 示 修 改-----------------


//后续 内容 无需 修改//后续 内容 无需 修改
//后续 内容 无需 修改//后续 内容 无需 修改
//后续 内容 无需 修改//后续 内容 无需 修改
//后续 内容 无需 修改//后续 内容 无需 修改


    int i, j, k;
    ArcNode *arc;
    VertexType v1, v2;

    printf("---icoding---\n6-2邻接表1\n");
    printf("icoding使用数字表示顶点集，为了方便，本例用大写字母表示顶点集\n");
    printf(">>正在初始化\n");

    for (i = 0; i < G.vexnum; ++i) {
        G.vertex[i].data=i+'A';
        G.vertex[i].firstarc = NULL; //将边表置为空
    }

    

        
        
        int size_arc1=sizeof(arc1)/sizeof(arc1[0]);
        int size_arc2=sizeof(arc2)/sizeof(arc2[0]);
        if(size_arc1!=size_arc2){
            printf("错误,测试样例输入的起点和终点顶点个数不相等，程序自动终止。\n请修改main函数的arc1[]与arc2[]数组，保持数量一致\n");
            return 0;
        }

        
        
       


        for(int m=0;m<size_arc1;m++){
            for(int n=0;n<size_arc1;n++)
            {
                if(arc1[m]==arc1[n]&&m!=n){
                    if(arc2[m]==arc2[n]){
                    printf("错误,测试样例输入的边有重复，暂不支持重复边，程序自动终止。\n");
                    printf("其中存在至少两处[%c]-->[%c]\n请修改main函数的arc1[]与arc2[]数组\n",arc1[m],arc2[n]);
                    return 0;
                }
                }
            }
        }

        G.arcnum=size_arc1;//边数
        int ring=0;//环标志
        //检查无向图是否有对称性
        if(G.type==UDG){
        int duichen=0;
        int m=0;
        for( m=0;m<size_arc1;m++){
            duichen=0;
            if(arc1[m]==arc2[m]){
                    duichen=1;
                    ring++;
            }
            for(int n=0;duichen==0&&n<size_arc1;n++){
                
                if(arc1[m]==arc2[n]&&m!=n){
                    if(arc2[m]==arc1[n]){
                        duichen=1;
                    }
                }
                }
            if(duichen==0){
                printf("错误,对于无向图，测试样例输入的边不具有有对称性，程序自动终止。\n");
                printf("其中缺失[%c]-->[%c]但有其反向通路\n请修改main函数的arc1[]与arc2[]数组\n",arc2[m],arc1[m]);
                printf("若要使用有向图，请修改main函数的G.type=DG\n");
                return 0;
            }
            }

            G.arcnum=(G.arcnum-ring)/2+ring;//无向图，（边数-环）/2+环数
            
        }
        int init_arcnum=G.arcnum;//记录初始边数


        for(int cou=0;cou<size_arc1;cou++){
            if((arc1[cou]>'Z'||arc1[cou]<'A')||(arc2[cou]>'Z'||arc2[cou]<'A')){
                printf("错误,测试样例输入的边标号非A-Z值，程序自动终止。\n请修改main函数的arc1[]与arc2[]数组\n");
                return 0;
            }
        i = locate_vertex(&G, arc1[cou]); //v1顶点所在顶点数组中的下标值。
        j = locate_vertex(&G, arc2[cou]); //v2顶点所在数组中的下标值。
        //如果arc[]的值在图中不存在，则报错
        if (i == -1 || j == -1) {
            printf("错误，测试样例初始化输入的边标号不存在，程序自动终止。\n请修改main函数的arc1[]与arc2[]数组\n");
            return 0;
        }
        arc = (ArcNode *)malloc(sizeof(ArcNode));
        arc->adjvex = j;
        arc->nextarc = G.vertex[i].firstarc; //头插法建立边表
        
        G.vertex[i].firstarc = arc; //把新建的结点链接在顶点后面
    }

    
    //打印图的基本信息
    printf("·初始化信息·    图的顶点:%d\t图的边数:%d\t",G.vexnum,G.arcnum);
    if(G.type==UDG)printf("图的种类：无向图");
    else if(G.type==DG)printf("图的种类：有向图");
    else {
        printf("图的种类未定义，请修改main函数的G.type值,程序自动退出\n");
        return 0; 
    }
    if(ring!=0){
    printf("\n\t      此图最初含有%d个环,后续函数不检测环\n",ring);
    }
    putchar('\n');

    DrawGraph(&G);
    printf("说明：数字表示顶点字母对应在顶点数组中的下标值，^表示此表为空\n");
    putchar('\n');

    int vbool=0,abool=0;

    if(flag==0||flag==2){
        printf(">>顶点插入\n插入%c\t",insert_ver);
        vbool=insert_vertex(&G,insert_ver);
        if(!vbool){
            printf("函数返回false\n");
        }else{
            printf("函数返回true\n");

            printf("·插入顶点后·    图的顶点:%d\t图的边数:%d\t",G.vexnum,G.arcnum);
            if(G.type==UDG)printf("图的种类：无向图");
            else if(G.type==DG)printf("图的种类：有向图");
            else {
                printf("图的种类未定义，请修改main函数的G.type值,程序自动退出\n");
                return 0; 
            }
            putchar('\n');

            DrawGraph(&G);
            putchar('\n');

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


    if(flag==0||flag==3){
        if(G.type==UDG){
        printf(">>边插入\n插入%c<-->%c\t",insert_arc_v1,insert_arc_v2);
        }
        else if(G.type==DG){
            printf(">>边插入\n插入%c-->%c\t",insert_arc_v1,insert_arc_v2);
        }

        abool=insert_arc(&G,insert_arc_v1,insert_arc_v2);
        if(!abool){
            printf("函数返回false\n");
        }else{
            printf("函数返回true\n");

            printf("·插入边后·    图的顶点:%d\t图的边数:%d\t",G.vexnum,G.arcnum);
            if(G.type==UDG)printf("图的种类：无向图");
            else if(G.type==DG)printf("图的种类：有向图");
            else {
                printf("图的种类未定义，请修改main函数的G.type值,程序自动退出\n");
                return 0; 
            }
            putchar('\n');

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

        }
        

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


        printf("\n\n---测试结束---\n");
    return 0;
}

如果不对main函数进行任何改动，正确的输出结果应该是