图子系统

图子系统

1.实验目的

（1）掌握图邻接矩阵的存储方法。

（2）掌握图深度优先遍历的基本思想。

（3）掌握图广度优先遍历的基本思想。

2.实验内容

（1）编写按键盘输入的数据建立图的邻接矩阵存储。

（2）编写图的深度优先遍历函数。

（3）编写图的广度优先遍历函数。

（4）设计一个选择式菜单如下：

                              图  子  系  统               

           **************************************************

            *          1---------更新邻接矩阵                * 

            *          2---------深度优先遍历                * 

            *          3---------广度优先遍历                *

            *          0---------退       出                    *  

            **************************************************

   请选择菜单号(0---3):     

附C源程序如下：

#include <stdio.h>
#define GRAPHMAX 10
#define Queuesize 30

typedef struct
{  char vexs[GRAPHMAX];
   int edges[GRAPHMAX][GRAPHMAX];
   int n,e;
}MGraph;

int visited[10];

void CreateMGraph(MGraph *G);

void DFSTraverseM(MGraph *G);
void DFSM(MGraph *G,int i);

void BFSTraverseM(MGraph *G);
void BFSM(MGraph *G,int k);

typedef struct
{  int front;
   int rear;
   int count;
   int data[Queuesize];
}CirQueue;

void InitQueue(CirQueue *Q)
{  Q->front=Q->rear=0;
   Q->count=0;
}

int QueueEmpty(CirQueue *Q)
{
   return Q->count==0;
}

int QueueFull(CirQueue *Q)
{
   return Q->count==Queuesize;
}

void EnQueue(CirQueue *Q,int x)
{
   if(QueueFull(Q))
      printf("Error! Queue overflow.");
   else
   {  Q->count++;
      Q->data[Q->rear]=x;
      Q->rear=(Q->rear+1)%Queuesize;
   }
}

int DeQueue(CirQueue *Q)
{  int temp;
   if (QueueEmpty(Q))
   {  printf("Error! Queue underflow.");
      return NULL;
   }
   else
   {  temp=Q->data[Q->front];
      Q->count--;
      Q->front=(Q->front+1)%Queuesize;
      return temp;
   }
}

void main() 
{  MGraph *G,a;  //定义a 为一个MGraph 类型结构变量，则 a 的存储单元就确定下来
   char ch1;
   int ch2;
   G=&a;

   printf("
		 建立一个图的邻接矩阵存储结构:
");
   CreateMGraph(G);
   

   getchar();
   ch1='y';
   while (ch1=='y'|| ch1=='Y')
  {
     printf("
");
     printf("
		                   图  子  系  统                 ");
     printf("
		**************************************************");
     printf("
		*          1---------更新邻接矩阵                *");  
     printf("
		*          2---------深度优先遍历                *");  
     printf("
		*          3---------广度优先遍历                *");  
     printf("
		*          0---------退        出                *");      
     printf("
		**************************************************");
     printf("
		   请选择菜单号(0---3):            ");
     scanf("%d",&ch2);
     getchar();
     switch(ch2)
     {   case 1:
               CreateMGraph(G);
               printf("
		 图的邻接矩阵存储结构建立完毕.");
               break;
         case 2:
               DFSTraverseM(G);
               break;
         case 3:    
                 BFSTraverseM(G);
               break;  
         case 0:
               ch1='n';
               break;
         default:
               printf("
		 输入错误！请重新输入  ");
     }
  }
}


void CreateMGraph(MGraph *G)  //建立图的邻接矩阵存储
{ int i,j,k;
  char ch1,ch2;

  printf("
		 请输入顶点数,边数并按回车(格式如：3,4):");
  scanf("%d,%d",&(G->n),&(G->e));  //输入顶点数，边数

  for (i=0; i<G->n; i++) //输入各顶点符号
  { 
     getchar();
     printf("
		 请输入第 %d 个顶点并按回车:  ",i+1);
     scanf("%c", &(G->vexs[i]));
  }
  
  for(i=0; i<G->n; i++)
     for(j=0; j<G->n; j++)
         G->edges[i][j]=0;

  for(k=0;  k<G->e; k++)
  {  getchar();
     printf("
		 请输入第 %d 条边的顶点符号(格式为：顶点符号,顶点符号):",k+1);
     scanf("%c,%c",&ch1,&ch2);
     for(i=0;ch1!=G->vexs[i];i++);
     for(j=0;ch2!=G->vexs[j];j++);
     G->edges[i][j]=1;
  }

  printf("
		 已建立一个图的邻接矩阵存储结构!现输出此邻接矩阵如下：
");
  for(i=0; i<G->n; i++)  //输出此邻接矩阵
  {  printf("
		");
     for(j=0; j<G->n; j++)
        printf("%5d",G->edges[i][j]);
  }

}

void DFSTraverseM(MGraph *G) //深度优先遍历
{ int i;
  for(i=0; i<G->n; i++)
      visited[i]=0;

  for(i=0; i<G->n; i++)
      if(!visited[i])
          DFSM(G,i);
}

void DFSM(MGraph *G,int i)  
{ int j;
  printf("
		 深度优先遍历序列：%c
", G->vexs[i]);
  visited[i]=1;
  for(j=0; j<G->n; j++)
     if( G->edges[i][j]==1 && !visited[j])
        DFSM(G,j); // 递归调用DFSM()，直到没有未被访问的相邻顶点，则访问后返回到上一层
}

void BFSTraverseM(MGraph *G)
{ int i;
  for(i=0; i<G->n; i++)
      visited[i]=0;

  for(i=0; i<G->n; i++)
      if(!visited[i])
        BFSM(G,i);
}

void BFSM(MGraph *G, int k)
{ int i,j;
  CirQueue Q; //定义 Q 为一个循环队列结构变量

  InitQueue(&Q);

  printf("
		  广度优先遍历序列：  %c
", G->vexs[k]);  //访问此顶点
  visited[k]=1;  // 将该顶点的访问标志置为已访问
  EnQueue(&Q,k);  // 将该顶点的序号进对
  
  while( !QueueEmpty(&Q) )
  {  i=DeQueue(&Q); //已访问顶点的序号从对首出对
     for(j=0; j<G->n; j++)
       if( G->edges[i][j]==1 && !visited[j] )  //如果 j 是 i 的邻接点并且 j 未被访问过
       {  printf("
		  广度优先遍历序列：  %c
", G->vexs[j]); 
          visited[j]=1;
          EnQueue(&Q,j); // j 被访问后进对尾
       }
  }
}