实验：图的应用

算法1：输入图的类型、顶点数、狐（边）数、顶点信息、狐（边）信息，建立相应的图(具体类型可以是无向图、有向图、无向网、有向网，采用邻接矩阵存储结构)；分别按深度优先搜索和广度优先搜索遍历图；按某种形式输出图及遍历结果。

实验源代码
#include <stdio.h>   
#include <stdlib.h>
#define OVERFLOW -2         
#define ILLEGAL -1         
#define OK 1                
#define ERROR 0
#define MAXQSIZE 100       
typedef int QElemType;
typedef int Status;       
typedef float ElemType;
#define INFINITY        65535    
#define MAX_VERTEX_NUM  20//最大顶点个数
typedef enum {DG,UDG} GraphKind;//（有向图，无向图）
typedef int VRType;
typedef int VertexType;
typedef struct ArcCell{
VRType   adj; 
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; 
typedef struct{
VertexType vexs[MAX_VERTEX_NUM];//顶点向量
AdjMatrix  arcs;//邻接矩阵
int vexnum,arcnum;//图当前的定点数和弧数
GraphKind  kind;     
}MGraph; 
int LocateVex(MGraph G, int v){  
for(int i=0;i<=G.vexnum;++i)
if(G.vexs[i]==v)  
return i;   
return -1;  
}
Status CreateDG(MGraph &G){
//采用数组（邻接矩阵）表示法，构造有向图G 
VertexType v1,v2;
int i,j;
printf("请依次输入有向图G的顶点数，弧数，用空格隔开\n");
scanf("%d %d",&G.vexnum,&G.arcnum);
printf("请依次输入有向图G的顶点名称，用空格隔开\n"); 
for(int i=0;i<G.vexnum;++i)
scanf("%d",&G.vexs[i]);  
for(int i=0;i<G.vexnum;++i)
    for(int j=0;j<G.vexnum;++j)
      G.arcs[i][j].adj=0; 
printf("请依次输入有向图G每条弧依附的两顶点名称，输完一组按回车\n"); 
for(int k=0;k<G.arcnum;++k){ 
scanf("%d",&v1);
scanf("%d",&v2);
i=LocateVex(G,v1);
j=LocateVex(G,v2);    
G.arcs[i][j].adj=1;
}
return OK; 
}
Status CreateUDG(MGraph &G){
//采用数组（邻接矩阵）表示法，构造无向图G 
VertexType v1,v2;
int i,j;
printf("请依次输入无向图G的顶点数，弧数，用空格隔开\n");
scanf("%d %d",&G.vexnum,&G.arcnum);
printf("请依次输入无向图G的顶点名称，用空格隔开\n"); 
for(int i=0;i<G.vexnum;++i)
scanf("%d",&G.vexs[i]);   
for(int i=0;i<G.vexnum;++i)
for(int j=0;j<G.vexnum;++j)  
G.arcs[i][j].adj=0; 
printf("请依次输入无向图G每条弧依附的两顶点名称，输完一组按回车\n"); 
for(int k=0;k<G.arcnum;++k){  
scanf("%d",&v1);
scanf("%d",&v2);
i=LocateVex(G,v1);
j=LocateVex(G,v2);      
G.arcs[i][j].adj=1;
G.arcs[j][i]=G.arcs[i][j];  
}
return OK; 
}
Status CreateGraph(MGraph &G){  
//采用数组（邻接矩阵）表示法，构造图G
printf("请输入您想构造的图的类型:有向图,无向图，分别对应0,1");
int temp; 
scanf("%d",&temp);  
G.kind=(GraphKind)temp;
switch((GraphKind)temp){
case  DG:  return CreateDG(G);  
case UDG:  return CreateUDG(G);
default:  return ERROR;
} 
}
Status PrintAdjMatrix(MGraph G){  
//采用数组（邻接矩阵）表示法，构造图G
for(int i=0;i<G.vexnum;i++){
for(int j=0;j<G.vexnum;j++)
printf(" %3d ", G.arcs[i][j].adj);
printf("\n\n");
}  
}
int FirstAdjVex(MGraph G,VertexType v){
//求顶点v在图G中的第一个邻接点
int i,j=0,k;
k=LocateVex(G,v); 
for(i=0;i<G.vexnum;++i)
if(G.arcs[k][i].adj!=j)
return i;        
return -1;             
}
int NextAdjVex(MGraph G,VertexType v,VertexType w){ 
int i,j=0,k1,k2;
k1=LocateVex(G,v);  
k2=LocateVex(G,w);  
for(i=k2+1;i<G.vexnum;++i)
if(G.arcs[k1][i].adj!=j)
return i;       
return -1;            
}
typedef enum { TRUE=1 , FALSE=0 } Boolean; 
Boolean visited[MAX_VERTEX_NUM];    
Status (*VisitFunc)(int v);        
Status Print(int v){  
printf("%3d",v);
return OK;
}
void DFSTraverse(MGraph G,Status (*Visit)(int v)){
//对图G作深度优先遍历
void DFS(MGraph G,int v);   
VisitFunc=Visit;         
for(int v=0;v<G.vexnum;++v)
visited[v]=FALSE;    
for(int v=0;v<G.vexnum;++v)
if(!visited[v])   
DFS(G,v); 
}
void DFS(MGraph G,int v){
//从第v个顶点出发递归地深度优先遍历图G
visited[v]=TRUE;    
VisitFunc(G.vexs[v]);   
for(int w=FirstAdjVex(G,G.vexs[v]);w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])){
if(!visited[w])
DFS(G,w);    
}
}
typedef struct              
{
QElemType *base;        
int front;              
int rear;              
}SqQueue; 
Status InitQueue_Sq(SqQueue &Q) 
{   
if(!(Q.base=(QElemType *)malloc(sizeof(QElemType)))){
printf("内存分配失败，程序即将退出！\n");
exit(OVERFLOW);
}
Q.front=Q.rear=0;
return OK;
}
Status DestoryQueue_Sq(SqQueue &Q)
{   
free(Q.base); 
Q.base=NULL;
printf("循环队列已成功销毁！\n");
return OK;
}
Status QueueEmpty_Sq(SqQueue Q)
{  
if(Q.rear==Q.front) 
return OK; 
else
return ERROR; 
}
Status EnQueue_Sq(SqQueue &Q,QElemType e)
{   
if((Q.rear+1)%MAXQSIZE==Q.front)  
return ERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%MAXQSIZE;   
return OK; 
}
Status DeQueue_Sq(SqQueue &Q,QElemType &e)
{   
if(Q.front==Q.rear) 
return ERROR;
e=Q.base[Q.front];
Q.front=(Q.front+1)%MAXQSIZE;  
return OK; 
} 
void BFSTraverse(MGraph G,Status (*Visit)(int v)){
//按广度优先非递归遍历图G，
SqQueue Q; 
for(int v=0;v<G.vexnum;++v)
visited[v]=FALSE;    
InitQueue_Sq(Q);          
for(int v=0;v<G.vexnum;++v)
if(!visited[v]){        
visited[v]=TRUE;  
Visit(G.vexs[v]);   
EnQueue_Sq(Q,v);    
while(!QueueEmpty_Sq(Q)){    
DeQueue_Sq(Q,v);      
for(int w=FirstAdjVex(G,G.vexs[v]);w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])){ 
        if(!visited[w]){   
           visited[w]=TRUE;  
                Visit(G.vexs[w]);    
      }
    } 
   }
  }
}
int main(int argc,char *argv[]){
MGraph G; 
CreateGraph(G);      
printf(" 图的邻接矩阵：\n\n"); 
PrintAdjMatrix(G);   
printf("图的遍历:\n");
printf("深度优先遍历结果：");
DFSTraverse(G,Print);
printf("\n广度优先遍历结果：");
BFSTraverse(G,Print); 
return 0;
}