（4）验收/测试用例                

l 创建所示无向图

屏幕输出邻接矩阵

     0  1  0  0  0  1

     1  0  1  1  0  0

     0  1  0  1  1  0

     0  1  1  0  1  0

     0  0  1  1  0  1

     1  0  0  0  1  0

l 深度优先遍历

屏幕输出： 1 2 3 4 5 6

l 广度优先遍历

屏幕输出：1 2 6 3 4 5

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 20
#define OK 1
#define ERROR 1
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
typedef int VertexType;
typedef int VRType;
typedef int Boolean;
typedef struct ArcCell {
    VRType adj;
}AdjMaxtrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
    VertexType vexs[MAX_VERTEX_NUM];
    AdjMaxtrix arcs;
    int vexnum,arcnum;
}MGraph;
typedef struct QNode {//队列节点结构体 
    int data;
    struct QNode *next;
} QNode,*QueuePtr;
typedef struct {
    QueuePtr front;
    QueuePtr rear;//队头，队尾指针 
}LinkQueue;
int LocateVex(MGraph G,int num)
{ 
    for(int i = 0;i<G.vexnum;i++){
        if( G.vexs[i] ==num)
            return i;
    }
    return -1;
}
void CreateGraph(MGraph *G)
{
    int i,j,k,v1,v2;
    printf("输入顶点数和边数：\n");
    scanf("%d %d",&G->vexnum,&G->arcnum);//输入顶点数和边数
    printf ("请输入所有顶点：");
    for (i=0;i<G->vexnum;i++) 
    {
        scanf ("%d",&G->vexs[i]);
    }
    for (i=0;i<G->vexnum;i++) 
    {
        for (j=0;j<G->vexnum;j++) 
        {
            G->arcs[i][j].adj = 0;
        }
    }
    for (k=0;k<G->arcnum;k++) 
    {
        printf ("请输入一条边所依附的顶点：");
        scanf ("%d %d",&v1,&v2);
        i=LocateVex(*G,v1);
        j=LocateVex(*G,v2);
        if (i!=-1&&j!=-1) 
        {
            G->arcs[i][j].adj = 1;
            G->arcs[j][i].adj = 1;
        }
    }
}
int PrintGraph(MGraph G)
{
    int i,j;
    for(i=0;i<G.vexnum;i++)
    {
        for(j=0;j<G.vexnum;j++)
        {
            printf("%3d", G.arcs[i][j]);
        }
        printf("\n");
    }
    return 0;
}
int FirstAdjVex(MGraph G,int v)//查找第一个临界点 
{
    int j,p=-1;
    for(j=0;j<G.vexnum;j++)
    {
        if(G.arcs[v][j].adj==1)
        {
            p=j;
            break;
        }
    }	
    return p;
} 
int NextAdjVex(MGraph G,int v,int w)//查找下一个临界点
{
    int j,p=-1;
    for(j=w+1;j<G.vexnum;j++)
    {
        if(G.arcs[v][j].adj==1)
        {
            p=j;
            break;
        }
    }
    return p;
}
Boolean visited[MAX_VERTEX_NUM];//设置全局变量，深度遍历 
void Dfs(MGraph G,int v)
{
    int w;
    visited[v]=TRUE;
    printf("%d ",G.vexs[v]);
    for(w =FirstAdjVex(G,v);w>=0;w = NextAdjVex (G,v,w)) 
    {
        if (!visited [w]) 
        {
            Dfs(G,w);
        }
    }
}
void DfsTraverse(MGraph G) 
{
    int v;
    for(v=0;v<G.vexnum;v++) 
    {
        visited[v]=FALSE;
    }
    for(v=0;v<G.vexnum;v++) 
    {
        if (!visited[v]) 
        {
            Dfs(G,v);
        }
    }
}
void InitQueue(LinkQueue *Q)
{  
    (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));  
    if((*Q).front)   
        (*Q).front->next=NULL; 
}  
int QueueEmpty(LinkQueue Q)
{  
    if(Q.front==Q.rear) return 0;  
    return 1; 
}
void EnQueue(LinkQueue *Q,int T)
{  
    QueuePtr p;  
    p=(QueuePtr)malloc(sizeof(QNode));  
    if(p)   
        p->data=T;
        p->next=NULL;         
        (*Q).rear->next=p;   
        (*Q).rear=p; 
}
void DeQueue(LinkQueue *Q,int *e)
{  
    QueuePtr p;  
    if((*Q).front!=(*Q).rear)
    {   
        p=(*Q).front->next;   
        *e=p->data;   
        (*Q).front->next=p->next;  
    if((*Q).rear==p)   
        (*Q).rear=(*Q).front;  
    free(p);  
    } 
} 
void BfsTraverse(MGraph G)
{
    int v,u,w;
    LinkQueue Q;
    for(v=0;v<G.vexnum;v++)
    visited[v]=FALSE;
    InitQueue(&Q);
    for (v=0;v<G.vexnum;v++) 
    {
        if (!visited[v]) 
        {
            visited[v]=TRUE;
            printf("%d ",G.vexs[v]);
            EnQueue (&Q,v);
            while (Q.front!=Q.rear) 
            {
                DeQueue(&Q,&u);
                for (w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w)) 
                {
                    if (!visited[w]) 
                    {
                        visited[w]=TRUE;
                        printf("%d ",G.vexs[w]);
                        EnQueue (&Q,w);
                    }
                }
            }
        }
    }
}
int main()
{
    printf("***************************************\n");
    printf("*************** 无向网图 **************\n");
    printf("***************************************\n");
    printf("************ 1.构建网图  **************\n");
    printf("************ 2.输出邻接矩阵  **********\n");
    printf("************ 3.深度优先遍历  **********\n");
    printf("************ 4.广度优先遍历  **********\n");
    printf("************ 5.退出  ******************\n");
    printf("***************************************\n");
    while(true)
    {
        int num1;
        printf("请选择："); 
        scanf("%d",&num1);
        if(num1==5) break;
        MGraph G; 
        switch(num1)
        {
            case 1:
                CreateGraph(&G);
                break;
            case 2:
                printf("邻接矩阵:\n");
                PrintGraph(G);
                break;
            case 3:
                printf("深度遍历:");
                DfsTraverse(G);
                printf("\n");
                break;
            case 4:
                printf("广度遍历:");
                BfsTraverse(G);
                printf("\n");
                break;
        }
    } 
    return 0;
}