C语言 算法与数据结构 图的邻接矩阵 邻接链表 深度 广度 遍历

C语言 算法与数据结构 图的邻接矩阵 邻接链表 深度 广度 遍历

实验要求：

1．实现无向图邻接矩阵的创建；设计算法输无向图邻接矩阵, 并利用邻接矩阵作为存储结构实现无向图的深度优先遍历；
2．实现无向图邻接表的创建；设计算法输无向图邻接表,并利用邻接表作为存储结构实现无向图的广度优先遍历；

#include 
#include 
#include 
#include 
#include 
#include 
#define TRUE 1
#define FALSE 0
#define MAXVER 100
/*
Item:
1．实现无向图邻接矩阵的创建；设计算法输无向图邻接矩阵, 并利用邻接矩阵作为存储结构实现无向图的深度优先遍历；
2．实现无向图邻接表的创建；设计算法输无向图邻接表,并利用邻接表作为存储结构实现无向图的广度优先遍历；
*/

/*Data design*/
/*1*/
typedef int vertype;
typedef struct
{
    vertype vex[MAXVER];
    int adjmatrix[MAXVER][MAXVER];
    int n,e;
} MapGraph;
/*2*/
typedef struct vernode
{
    int adjvex;
    struct vernode * next;
} nodetype;
typedef struct
{
    vertype data;
    nodetype * fnext;
} headnode;
typedef struct
{
    headnode maplist[MAXVER];
    int len;
} adjlist;


/*Function define*/
char Meau();    /*获得选择*/
void Help();    /*查看说明*/
void ChangeEndFlage();  /*修改结束标志符*/
/*1*/
void BuildGraph(MapGraph * map);    /*建立邻接矩阵*/
void DeepTravers(MapGraph * map);   /*借鉴教材函数实现，深度遍历函数顶点部分*/
void DeepTreversNext(MapGraph * map,int node);  /*深度遍历函数剩下尾部部分*/
int visit[MAXVER]= {0}; /*记录邻接矩阵深度遍历的数组*/
/*2*/
void BuildGraList(adjlist * adjlistmap);    /*建立邻接表*/
void BroadTravers(adjlist * adjlistmap);    /*广度遍历邻接表*/

int endflag=-999;
int main()
{
    system("color f5");
    system("title PhotoMap Dev Ice2Faith");
    ChangeEndFlage();
    char sel;
    do
    {
        sel=Meau();
        system("cls");
        switch(sel)
        {
        case '1':
        {
            MapGraph * map=(MapGraph *)malloc(sizeof(MapGraph));
            BuildGraph(map);
            printf("深度遍历结果：\n>/ ");
            DeepTravers(map);
            break;
        }
        case '2':
        {
            adjlist * adjlistmap=(adjlist *)malloc(sizeof(adjlist));
            BuildGraList(adjlistmap);
            printf("广度遍历结果：\n>/ ");
            BroadTravers(adjlistmap);
            break;
        }
        case '3':
        {
            Help();
            break;
        }
        case '0':
        {
            printf("正在退出程序，请稍候. . . \n\n");
            Sleep(800);
            break;
        }
        }
        if(sel!='0')
        {
            printf("\n\n");
            system("pause");
        }

    }
    while(sel!='0');

    return 0;
}

char Meau()
{
    system("cls");
    char sel='+';
    printf("----------------------------\n\n");
    printf("\t1.邻接矩阵\n\n");
    printf("\t2.邻接表\n\n");
    printf("\t3.帮助&说明\n\n");
    printf("\t0.退出程序\n\n");
    printf("----------------------------\n\n");
    printf(">/ ");
    do
    {
        sel=getch();
    }
    while(sel<'0'||sel>'3');
    printf("%c\n",sel);
    return sel;
}
void Help()
{
    printf("--------------------------------------------------------\n\n");
    printf("\t1.设计的图均是无向图,切均是面向整数（int）进行操作\n\n");
    printf("\t2.输入顶点之间的关系时本程序不负责检验是否合法\n\n");
    printf("\t3.部分函数借鉴书本参考\n\n");
    printf("\t4.请注意输入格式要求，默认结束标记 \"-999\" && \"-999+-999\"\n\n");
    printf("\t5.结束标记可支持修改\n\n");
    printf("\t6.Dev： Ice2Faith\n\n");
    printf("--------------------------------------------------------\n\n");

}
void ChangeEndFlage()
{
    system("cls");
    printf("您即将会输入使用的结束标志为：\"%d\"  && \"%d+%d\"\n",endflag,endflag,endflag);
    printf("需要修改请输入 1 \n>/ ");
    if(getch()=='1')
    {
        printf("请输入结束标记（int）：\n>/ ");
        scanf("%d",&endflag);
        printf("结束标记符已修改为：\"%d\"  && \"%d+%d\"\n\n",endflag,endflag,endflag);
        system("pause");
    }
}
void BuildGraph(MapGraph * map)
{
    for(int m=0; m<MAXVER; m++)
        for(int n=0; n<MAXVER; n++) /*清空邻接矩阵*/
            map->adjmatrix[m][n]=0;
    printf("请输入所有元素，以%d结束：\n",endflag);
    int i=0;
    int tempnum;
    do
    {
        scanf("%d",&tempnum);
        if(tempnum!=endflag)
            map->vex[i++]=tempnum;
        else
            break;
    }
    while(tempnum!=endflag);   /*读入元素*/
    map->n=i;   /*记录元素个数*/

    printf("请输入他们的关系，以%d+%d结束：例如11+12\n",endflag,endflag);
    int line,col;
    int j;
    int e=0;
    do
    {
        scanf("%d+%d",&line,&col);
        if(line==endflag&&col==endflag)
            break;
        for(i=0; i<map->n; i++)
        {
            if(map->vex[i]==line)
                break;
        }
        for(j=0; j<map->n; j++)
        {
            if(map->vex[j]==col)
                break;
        }
        map->adjmatrix[i][j]=1;
        map->adjmatrix[j][i]=1;
        e++;
    }
    while(line!=endflag&&col!=endflag);   /*读写关系到矩阵*/
    map->e=e;   /*记录边数*/
}

void DeepTravers(MapGraph * map)
{
    for(int j=0; j<MAXVER; j++) /*清空访问数组*/
        visit[j]=0;
    for(int i=0; i<map->n; i++) /*扫描每个元素*/
    {
        if(!visit[i])   /*若元素未被访问，则访问与它临街的第一个元素*/
        {
            DeepTreversNext(map,i);
        }
    }

}
void DeepTreversNext(MapGraph * map,int node)
{
    printf("->%d",map->vex[node]);  /*输出当前未访问并记录已访问*/
    visit[node]=1;
    for(int i=0; i<map->n; i++) /*查找对应矩阵行，找到第一个未访问进行访问，递归调用*/
    {
        if(!visit[i]&&map->adjmatrix[node][i])
        {
            DeepTreversNext(map,i);
        }
    }
}

void BuildGraList(adjlist * adjlistmap)
{
    printf("请输入顶点，以%d结束：\n",endflag);
    int tempnum;
    int i=0;
    do
    {
        scanf("%d",&tempnum);
        if(tempnum==endflag)
            break;
        adjlistmap->maplist[i].data=tempnum; /*顶点赋值并初始化第一个指针域*/
        adjlistmap->maplist[i].fnext=NULL;
        adjlistmap->len++;
        i++;
    }
    while(tempnum!=endflag);   /*获得顶点*/
    printf("顶点间的关系，例如3+5：以%d+%d结束：\n",endflag,endflag);
    int tempnum2;
    int j;
    nodetype * exnode=NULL;
    do
    {
        scanf("%d+%d",&tempnum,&tempnum2);
        if(tempnum2==endflag&&tempnum==endflag)
            break;
        nodetype * node=(nodetype *)malloc(sizeof(nodetype));
        node->next=NULL;
        nodetype * node1=(nodetype *)malloc(sizeof(nodetype));  /*创建两个节点*/
        node1->next=NULL;
        i=0;
        while(adjlistmap->maplist[i].data!=tempnum && i<adjlistmap->len)
        {
            i++;
        }
        j=0;
        while(adjlistmap->maplist[j].data!=tempnum2 && j<adjlistmap->len)   /*获得输入顶点之间关系对应的数组的下标*/
        {
            j++;
        }

        exnode=adjlistmap->maplist[i].fnext;
        adjlistmap->maplist[i].fnext=node;
        node->next=exnode;
        node->adjvex=j; /*对无向图一遍进行操作*/

        exnode=adjlistmap->maplist[j].fnext;
        adjlistmap->maplist[j].fnext=node1;
        node1->next=exnode;
        node1->adjvex=i;    /*另一边进行操作*/


    }
    while(tempnum2!=endflag&&tempnum!=endflag);   /*读入边之间的关系*/

}

void BroadTravers(adjlist * adjlistmap)
{
    int visit[MAXVER]= {0};
    for(int i=0; i<=adjlistmap->len; i++) /*初始化访问数组*/
        visit[i]=0;

    nodetype * tempnode=NULL;
    for(int i=0; i<adjlistmap->len; i++) /*遍历每个顶点*/
    {
        if(!visit[i])
        {
            printf("->%d",adjlistmap->maplist[i].data); /*对头指针进行遍历操作*/
            visit[i]=1;
        }
        tempnode=adjlistmap->maplist[i].fnext;
        while(tempnode) /*对此头指针之后的关系进行遍历*/
        {
            if(!visit[tempnode->adjvex])
            {
                printf("->%d",adjlistmap->maplist[tempnode->adjvex].data);
                visit[tempnode->adjvex]=1;
            }

            tempnode=tempnode->next;
        }
    }
}