圖的鄰接矩陣存儲

/* c7-1.h 圖的數組(鄰接矩陣)存儲表示 */ 
#define INFINITY INT_MAX  /* 用整型最大值代替∞ */ 
#define MAX_VERTEX_NUM 20  /* 最大頂點個數 */ 
typedef enum{DG,DN,AG,AN}GraphKind; /* {有向圖,有向網,無向圖,無向網}*/
typedef struct { 
   VRType adj; /* 頂點關係類型。對無權圖，用1(是)或0(否)表示相鄰否； */ 
   /* 對帶權圖，c則爲權值類型 */
   InfoType *info; /* 該弧相關信息的指針(可無) */ 
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct {
   VertexType vexs[MAX_VERTEX_NUM]; /* 頂點向量 */ 
   AdjMatrix arcs; /* 鄰接矩陣 */ 
   int vexnum,arcnum; /* 圖的當前頂點數和弧數 */ 
   GraphKind kind; /* 圖的種類標誌 */ 
}MGraph;

 /* algo7-1.c 調用算法7.七、7.8 */
 #include"c1.h"
 #define MAX_NAME 2 /* 頂點字符串的最大長度+1 */
 typedef char ElemType[MAX_NAME];
 typedef ElemType TElemType;
 #include"c6-5.h"
 typedef int InfoType;
 typedef char VertexType[MAX_NAME];
 #include"c7-2.h"
 #include"bo7-2.c"

 void DFSTree(ALGraph G,int v,CSTree *T)
 { /* 從第v個頂點出發深度優先遍歷圖G,創建以T爲根的生成樹。算法7.8 */
   Boolean first=TRUE;
   int w;
   CSTree p,q;
   VertexType v1,w1;
   visited[v]=TRUE;
   strcpy(v1,*GetVex(G,v));
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w)))) /* w依次爲v的鄰接頂點 */
     if(!visited[w]) /* w頂點未曾被訪問 */
     {
       p=(CSTree)malloc(sizeof(CSNode)); /* 分配孩子結點 */
       strcpy(p->data,*GetVex(G,w));
       p->firstchild=NULL;
       p->nextsibling=NULL;
       if(first)
       { /* w是v的第一個未被訪問的鄰接頂點 */
         (*T)->firstchild=p;
         first=FALSE; /* 是根的第一個孩子結點 */
       }
       else /* w是v的其它未被訪問的鄰接頂點 */
     q->nextsibling=p; /* 是上一鄰接頂點的兄弟姐妹結點 */
       q=p;
       DFSTree(G,w,&q); /* 從第w個頂點出發深度優先遍歷圖G,創建子生成樹q */
     }
 }

 void DFSForest(ALGraph G,CSTree *T)
 { /* 創建無向圖G的深度優先生成森林的(最左)孩子(右)兄弟鏈表T。算法7.7 */
   CSTree p,q;
   int v;
   *T=NULL;
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 賦初值 */
   for(v=0;v<G.vexnum;++v) /* 從第0個頂點找起 */
     if(!visited[v])
     { /* 第v頂點爲新的生成樹的根結點 */
       p=(CSTree)malloc(sizeof(CSNode)); /* 分配根結點 */
       strcpy(p->data,*GetVex(G,v));
       p->firstchild=NULL;
       p->nextsibling=NULL;
       if(!*T) /* 是第一棵生成樹的根(T的根) */
         *T=p;
       else /* 是其它生成樹的根(前一棵的根的＂兄弟＂) */
         q->nextsibling=p;
       q=p; /* q指示當前生成樹的根 */
       DFSTree(G,v,&p); /* 創建以p爲根的生成樹 */
     }
 }

 void PreOrderTraverse(CSTree T,void(*Visit)(TElemType))
 { /* 先根遍歷孩子－兄弟二叉鏈表結構的樹T(bo6-5.c改) */
   if(T)
   {
     Visit(T->data); /* 先訪問根結點 */
     PreOrderTraverse(T->firstchild,Visit); /* 再先根遍歷長子子樹 */
     PreOrderTraverse(T->nextsibling,Visit); /* 最後先根遍歷下一個兄弟子樹 */
   }
 }

 void print(char *i)
 {
   printf("%s ",i);
 }

 void main()
 {
   ALGraph g;
   CSTree t;
   printf("請選擇無向圖\n");
   CreateGraph(&g);
   Display(g);
   DFSForest(g,&t);
   printf("先根遍歷生成森林：\n");
   PreOrderTraverse(t,print);
   printf("\n");
 }

 /* bo7-1.c 圖的數組(鄰接矩陣)存儲(存儲結構由c7-1.h定義)的基本操做(20個) */
 int LocateVex(MGraph G,VertexType u)
 { /* 初始條件:圖G存在,u和G中頂點有相同特徵 */
   /* 操做結果:若G中存在頂點u,則返回該頂點在圖中位置;不然返回-1 */
   int i;
   for(i=0;i<G.vexnum;++i)
     if(strcmp(u,G.vexs[i])==0)
       return i;
   return -1;
 }

 Status CreateFAG(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,由文件構造沒有相關信息的無向圖G */
   int i,j,k;
   char filename[13];
   VertexType va,vb;
   FILE *graphlist;
   printf("請輸入數據文件名(f7-1.dat)：");
   scanf("%s",filename);
   graphlist=fopen(filename,"r");
   fscanf(graphlist,"%d",&(*G).vexnum);
   fscanf(graphlist,"%d",&(*G).arcnum);
   for(i=0;i<(*G).vexnum;++i) /* 構造頂點向量 */
     fscanf(graphlist,"%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化鄰接矩陣 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=0; /* 圖 */
       (*G).arcs[i][j].info=NULL; /* 沒有相關信息 */
     }
   for(k=0;k<(*G).arcnum;++k)
   {
     fscanf(graphlist,"%s%s",va,vb);
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=1; /* 無向圖 */
   }
   fclose(graphlist);
   (*G).kind=AG;
   return OK;
 }

 Status CreateDG(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,構造有向圖G */
   int i,j,k,l,IncInfo;
   char s[MAX_INFO],*info;
   VertexType va,vb;
   printf("請輸入有向圖G的頂點數,弧數,弧是否含其它信息(是:1,否:0): ");
   scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&IncInfo);
   printf("請輸入%d個頂點的值(<%d個字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 構造頂點向量 */
     scanf("%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化鄰接矩陣 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=0; /* 圖 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("請輸入%d條弧的弧尾 弧頭(以空格做爲間隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%*c",va,vb);  /* %*c吃掉回車符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=1; /* 有向圖 */
     if(IncInfo)
     {
       printf("請輸入該弧的相關信息(<%d個字符): ",MAX_INFO);
       gets(s);
       l=strlen(s);
       if(l)
       {
         info=(char*)malloc((l+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=info; /* 有向 */
       }
     }
   }
   (*G).kind=DG;
   return OK;
 }

 Status CreateDN(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,構造有向網G */
   int i,j,k,w,IncInfo;
   char s[MAX_INFO],*info;
   VertexType va,vb;
   printf("請輸入有向網G的頂點數,弧數,弧是否含其它信息(是:1,否:0): ");
   scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&IncInfo);
   printf("請輸入%d個頂點的值(<%d個字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 構造頂點向量 */
     scanf("%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化鄰接矩陣 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=INFINITY; /* 網 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("請輸入%d條弧的弧尾 弧頭 權值(以空格做爲間隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%d%*c",va,vb,&w);  /* %*c吃掉回車符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=w; /* 有向網 */
     if(IncInfo)
     {
       printf("請輸入該弧的相關信息(<%d個字符): ",MAX_INFO);
       gets(s);
       w=strlen(s);
       if(w)
       {
         info=(char*)malloc((w+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=info; /* 有向 */
       }
     }
   }
   (*G).kind=DN;
   return OK;
 }

 Status CreateAG(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,構造無向圖G */
   int i,j,k,l,IncInfo;
   char s[MAX_INFO],*info;
   VertexType va,vb;
   printf("請輸入無向圖G的頂點數,邊數,邊是否含其它信息(是:1,否:0): ");
   scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&IncInfo);
   printf("請輸入%d個頂點的值(<%d個字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 構造頂點向量 */
     scanf("%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化鄰接矩陣 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=0; /* 圖 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("請輸入%d條邊的頂點1 頂點2(以空格做爲間隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%*c",va,vb); /* %*c吃掉回車符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=1; /* 無向圖 */
     if(IncInfo)
     {
       printf("請輸入該邊的相關信息(<%d個字符): ",MAX_INFO);
       gets(s);
       l=strlen(s);
       if(l)
       {
         info=(char*)malloc((l+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=(*G).arcs[j][i].info=info; /* 無向 */
       }
     }
   }
   (*G).kind=AG;
   return OK;
 }

 Status CreateAN(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,構造無向網G。算法7.2 */
   int i,j,k,w,IncInfo;
   char s[MAX_INFO],*info;
   VertexType va,vb;
   printf("請輸入無向網G的頂點數,邊數,邊是否含其它信息(是:1,否:0): ");
   scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&IncInfo);
   printf("請輸入%d個頂點的值(<%d個字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 構造頂點向量 */
     scanf("%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化鄰接矩陣 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=INFINITY; /* 網 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("請輸入%d條邊的頂點1 頂點2 權值(以空格做爲間隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%d%*c",va,vb,&w); /* %*c吃掉回車符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=w; /* 無向 */
     if(IncInfo)
     {
       printf("請輸入該邊的相關信息(<%d個字符): ",MAX_INFO);
       gets(s);
       w=strlen(s);
       if(w)
       {
         info=(char*)malloc((w+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=(*G).arcs[j][i].info=info; /* 無向 */
       }
     }
   }
   (*G).kind=AN;
   return OK;
 }

 Status CreateGraph(MGraph *G)
 { /* 採用數組(鄰接矩陣)表示法,構造圖G。算法7.1 */
   printf("請輸入圖G的類型(有向圖:0,有向網:1,無向圖:2,無向網:3): ");
   scanf("%d",&(*G).kind);
   switch((*G).kind)
   {
     case DG: return CreateDG(G); /* 構造有向圖 */
     case DN: return CreateDN(G); /* 構造有向網 */
     case AG: return CreateAG(G); /* 構造無向圖 */
     case AN: return CreateAN(G); /* 構造無向網 */
     default: return ERROR;
   }
 }

 void DestroyGraph(MGraph *G)
 { /* 初始條件: 圖G存在。操做結果: 銷燬圖G */
   int i,j;
   if((*G).kind<2) /* 有向 */
     for(i=0;i<(*G).vexnum;i++) /* 釋放弧的相關信息(若是有的話) */
     {
       for(j=0;j<(*G).vexnum;j++)
         if((*G).arcs[i][j].adj==1&&(*G).kind==0||(*G).arcs[i][j].adj!=INFINITY&&(*G).kind==1) /* 有向圖的弧||有向網的弧 */
           if((*G).arcs[i][j].info) /* 有相關信息 */
           {
             free((*G).arcs[i][j].info);
             (*G).arcs[i][j].info=NULL;
           }
     }
   else /* 無向 */
     for(i=0;i<(*G).vexnum;i++) /* 釋放邊的相關信息(若是有的話) */
       for(j=i+1;j<(*G).vexnum;j++)
         if((*G).arcs[i][j].adj==1&&(*G).kind==2||(*G).arcs[i][j].adj!=INFINITY&&(*G).kind==3) /* 無向圖的邊||無向網的邊 */
           if((*G).arcs[i][j].info) /* 有相關信息 */
           {
             free((*G).arcs[i][j].info);
             (*G).arcs[i][j].info=(*G).arcs[j][i].info=NULL;
           }
   (*G).vexnum=0;
   (*G).arcnum=0;
 }

 VertexType* GetVex(MGraph G,int v)
 { /* 初始條件: 圖G存在，v是G中某個頂點的序號。操做結果: 返回v的值 */
   if(v>=G.vexnum||v<0)
     exit(ERROR);
   return &G.vexs[v];
 }

 Status PutVex(MGraph *G,VertexType v,VertexType value)
 { /* 初始條件: 圖G存在，v是G中某個頂點。操做結果: 對v賦新值value */
   int k;
   k=LocateVex(*G,v); /* k爲頂點v在圖G中的序號 */
   if(k<0)
     return ERROR;
   strcpy((*G).vexs[k],value);
   return OK;
 }

 int FirstAdjVex(MGraph G,VertexType v)
 { /* 初始條件: 圖G存在,v是G中某個頂點 */
   /* 操做結果: 返回v的第一個鄰接頂點的序號。若頂點在G中沒有鄰接頂點,則返回-1 */
   int i,j=0,k;
   k=LocateVex(G,v); /* k爲頂點v在圖G中的序號 */
   if(G.kind==DN||G.kind==AN) /* 網 */
     j=INFINITY;
   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)
 { /* 初始條件: 圖G存在,v是G中某個頂點,w是v的鄰接頂點 */
   /* 操做結果: 返回v的(相對於w的)下一個鄰接頂點的序號, */
   /*           若w是v的最後一個鄰接頂點,則返回-1 */
   int i,j=0,k1,k2;
   k1=LocateVex(G,v); /* k1爲頂點v在圖G中的序號 */
   k2=LocateVex(G,w); /* k2爲頂點w在圖G中的序號 */
   if(G.kind==DN||G.kind==AN) /* 網 */
     j=INFINITY;
   for(i=k2+1;i<G.vexnum;i++)
     if(G.arcs[k1][i].adj!=j)
       return i;
   return -1;
 }

 void InsertVex(MGraph *G,VertexType v)
 { /* 初始條件: 圖G存在,v和圖G中頂點有相同特徵 */
   /* 操做結果: 在圖G中增添新頂點v(不增添與頂點相關的弧,留待InsertArc()去作) */
   int i;
   strcpy((*G).vexs[(*G).vexnum],v); /* 構造新頂點向量 */
   for(i=0;i<=(*G).vexnum;i++)
   {
     if((*G).kind%2) /* 網 */
     {
       (*G).arcs[(*G).vexnum][i].adj=INFINITY; /* 初始化該行鄰接矩陣的值(無邊或弧) */
       (*G).arcs[i][(*G).vexnum].adj=INFINITY; /* 初始化該列鄰接矩陣的值(無邊或弧) */
     }
     else /* 圖 */
     {
       (*G).arcs[(*G).vexnum][i].adj=0; /* 初始化該行鄰接矩陣的值(無邊或弧) */
       (*G).arcs[i][(*G).vexnum].adj=0; /* 初始化該列鄰接矩陣的值(無邊或弧) */
     }
     (*G).arcs[(*G).vexnum][i].info=NULL; /* 初始化相關信息指針 */
     (*G).arcs[i][(*G).vexnum].info=NULL;
   }
   (*G).vexnum+=1; /* 圖G的頂點數加1 */
 }

 Status DeleteVex(MGraph *G,VertexType v)
 { /* 初始條件: 圖G存在,v是G中某個頂點。操做結果: 刪除G中頂點v及其相關的弧 */
   int i,j,k;
   VRType m=0;
   k=LocateVex(*G,v); /* k爲待刪除頂點v的序號 */
   if(k<0) /* v不是圖G的頂點 */
     return ERROR;
   if((*G).kind==DN||(*G).kind==AN) /* 網 */
     m=INFINITY;
   for(j=0;j<(*G).vexnum;j++)
     if((*G).arcs[j][k].adj!=m) /* 有入弧或邊 */
     {
       if((*G).arcs[j][k].info) /* 有相關信息 */
         free((*G).arcs[j][k].info); /* 釋放相關信息 */
       (*G).arcnum--; /* 修改弧數 */
     }
   if((*G).kind==DG||(*G).kind==DN) /* 有向 */
     for(j=0;j<(*G).vexnum;j++)
       if((*G).arcs[k][j].adj!=m) /* 有出弧 */
       {
         if((*G).arcs[k][j].info) /* 有相關信息 */
           free((*G).arcs[k][j].info); /* 釋放相關信息 */
         (*G).arcnum--; /* 修改弧數 */
       }
   for(j=k+1;j<(*G).vexnum;j++) /* 序號k後面的頂點向量依次前移 */
     strcpy((*G).vexs[j-1],(*G).vexs[j]);
   for(i=0;i<(*G).vexnum;i++)
     for(j=k+1;j<(*G).vexnum;j++)
       (*G).arcs[i][j-1]=(*G).arcs[i][j]; /* 移動待刪除頂點以後的矩陣元素 */
   for(i=0;i<(*G).vexnum;i++)
     for(j=k+1;j<(*G).vexnum;j++)
       (*G).arcs[j-1][i]=(*G).arcs[j][i]; /* 移動待刪除頂點之下的矩陣元素 */
   (*G).vexnum--; /* 更新圖的頂點數 */
   return OK;
 }

 Status InsertArc(MGraph *G,VertexType v,VertexType w)
 { /* 初始條件: 圖G存在,v和W是G中兩個頂點 */
   /* 操做結果: 在G中增添弧<v,w>,若G是無向的,則還增添對稱弧<w,v> */
   int i,l,v1,w1;
   char *info,s[MAX_INFO];
   v1=LocateVex(*G,v); /* 尾 */
   w1=LocateVex(*G,w); /* 頭 */
   if(v1<0||w1<0)
     return ERROR;
   (*G).arcnum++; /* 弧或邊數加1 */
   if((*G).kind%2) /* 網 */
   {
     printf("請輸入此弧或邊的權值: ");
     scanf("%d",&(*G).arcs[v1][w1].adj);
   }
   else /* 圖 */
     (*G).arcs[v1][w1].adj=1;
   printf("是否有該弧或邊的相關信息(0:無 1:有): ");
   scanf("%d%*c",&i);
   if(i)
   {
     printf("請輸入該弧或邊的相關信息(<%d個字符)：",MAX_INFO);
     gets(s);
     l=strlen(s);
     if(l)
     {
       info=(char*)malloc((l+1)*sizeof(char));
       strcpy(info,s);
       (*G).arcs[v1][w1].info=info;
     }
   }
   if((*G).kind>1) /* 無向 */
   {
     (*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
     (*G).arcs[w1][v1].info=(*G).arcs[v1][w1].info; /* 指向同一個相關信息 */
   }
   return OK;
 }

 Status DeleteArc(MGraph *G,VertexType v,VertexType w)
 { /* 初始條件: 圖G存在,v和w是G中兩個頂點 */
   /* 操做結果: 在G中刪除弧<v,w>,若G是無向的,則還刪除對稱弧<w,v> */
   int v1,w1;
   v1=LocateVex(*G,v); /* 尾 */
   w1=LocateVex(*G,w); /* 頭 */
   if(v1<0||w1<0) /* v一、w1的值不合法 */
     return ERROR;
   if((*G).kind%2==0) /* 圖 */
     (*G).arcs[v1][w1].adj=0;
   else /* 網 */
     (*G).arcs[v1][w1].adj=INFINITY;
   if((*G).arcs[v1][w1].info) /* 有其它信息 */
   {
     free((*G).arcs[v1][w1].info);
     (*G).arcs[v1][w1].info=NULL;
   }
   if((*G).kind>=2) /* 無向,刪除對稱弧<w,v> */
   {
     (*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
     (*G).arcs[w1][v1].info=NULL;
   }
   (*G).arcnum--;
   return OK;
 }

 Boolean visited[MAX_VERTEX_NUM]; /* 訪問標誌數組(全局量) */
 Status(*VisitFunc)(VertexType); /* 函數變量 */
 void DFS(MGraph G,int v)
 { /* 從第v個頂點出發遞歸地深度優先遍歷圖G。算法7.5 */
   VertexType w1,v1;
   int w;
   visited[v]=TRUE; /* 設置訪問標誌爲TRUE(已訪問) */
   VisitFunc(G.vexs[v]); /* 訪問第v個頂點 */
   strcpy(v1,*GetVex(G,v));
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
     if(!visited[w])
       DFS(G,w); /* 對v的還沒有訪問的序號爲w的鄰接頂點遞歸調用DFS */
 }

 void DFSTraverse(MGraph G,Status(*Visit)(VertexType))
 { /* 初始條件: 圖G存在,Visit是頂點的應用函數。算法7.4 */
   /* 操做結果: 從第1個頂點起,深度優先遍歷圖G,並對每一個頂點調用函數Visit */
   /*           一次且僅一次。一旦Visit()失敗,則操做失敗 */
   int v;
   VisitFunc=Visit; /* 使用全局變量VisitFunc,使DFS沒必要設函數指針參數 */
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 訪問標誌數組初始化(未被訪問) */
   for(v=0;v<G.vexnum;v++)
     if(!visited[v])
       DFS(G,v); /* 對還沒有訪問的頂點調用DFS */
   printf("\n");
 }

 typedef VRType QElemType; /* 隊列類型 */
 #include"c3-2.h" /* BFSTraverse()用 */
 #include"bo3-2.c" /* BFSTraverse()用 */
 void BFSTraverse(MGraph G,Status(*Visit)(VertexType))
 { /* 初始條件: 圖G存在,Visit是頂點的應用函數。算法7.6 */
   /* 操做結果: 從第1個頂點起,按廣度優先非遞歸遍歷圖G,並對每一個頂點調用函數 */
   /*           Visit一次且僅一次。一旦Visit()失敗,則操做失敗。 */
   /*           使用輔助隊列Q和訪問標誌數組visited */
   int v,u,w;
   VertexType w1,u1;
   LinkQueue Q;
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的輔助隊列Q */
   for(v=0;v<G.vexnum;v++)
     if(!visited[v]) /* v還沒有訪問 */
     {
       visited[v]=TRUE; /* 設置訪問標誌爲TRUE(已訪問) */
       Visit(G.vexs[v]);
       EnQueue(&Q,v); /* v入隊列 */
       while(!QueueEmpty(Q)) /* 隊列不空 */
       {
         DeQueue(&Q,&u); /* 隊頭元素出隊並置爲u */
         strcpy(u1,*GetVex(G,u));
         for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))
           if(!visited[w]) /* w爲u的還沒有訪問的鄰接頂點的序號 */
           {
             visited[w]=TRUE;
             Visit(G.vexs[w]);
             EnQueue(&Q,w);
           }
       }
     }
   printf("\n");
 }

 void Display(MGraph G)
 { /* 輸出鄰接矩陣G */
   int i,j;
   char s[7],s1[3];
   switch(G.kind)
   {
     case DG: strcpy(s,"有向圖\0");
              strcpy(s1,"弧\0");
              break;
     case DN: strcpy(s,"有向網\0");
              strcpy(s1,"弧\0");
              break;
     case AG: strcpy(s,"無向圖\0");
              strcpy(s1,"邊\0");
              break;
     case AN: strcpy(s,"無向網\0");
              strcpy(s1,"邊\0");
   }
   printf("%d個頂點%d條%s的%s\n",G.vexnum,G.arcnum,s1,s);
   for(i=0;i<G.vexnum;++i) /* 輸出G.vexs */
     printf("G.vexs[%d]=%s\n",i,G.vexs[i]);
   printf("G.arcs.adj:\n"); /* 輸出G.arcs.adj */
   for(i=0;i<G.vexnum;i++)
   {
     for(j=0;j<G.vexnum;j++)
       printf("%6d",G.arcs[i][j].adj);
     printf("\n");
   }
   printf("G.arcs.info:\n"); /* 輸出G.arcs.info */
   printf("頂點1(弧尾) 頂點2(弧頭) 該%s信息：\n",s1);
   if(G.kind<2) /* 有向 */
     for(i=0;i<G.vexnum;i++)
       for(j=0;j<G.vexnum;j++)
       {
         if(G.arcs[i][j].info)
           printf("%5s %11s     %s\n",G.vexs[i],G.vexs[j],G.arcs[i][j].info);
       }
   else /* 無向 */
   {
     for(i=0;i<G.vexnum;i++)
       for(j=i+1;j<G.vexnum;j++)
     if(G.arcs[i][j].info)
       printf("%5s %11s     %s\n",G.vexs[i],G.vexs[j],G.arcs[i][j].info);
   }
 }

 /* main7-1.c 檢驗bo7-1.c的主程序 */
 #include"c1.h"
 #define MAX_NAME 5 /* 頂點字符串的最大長度+1 */
 #define MAX_INFO 20 /* 相關信息字符串的最大長度+1 */
 typedef int VRType;
 typedef char InfoType;
 typedef char VertexType[MAX_NAME];
 #include"c7-1.h"
 #include"bo7-1.c"

 Status visit(VertexType i)
 {
   printf("%s ",i);
   return OK;
 }

 void main()
 {
   int i,j,k,n;
   VertexType v1,v2;
   MGraph g;
   CreateFAG(&g);
   Display(g);
   printf("修改頂點的值，請輸入原值 新值: ");
   scanf("%s%s",v1,v2);
   PutVex(&g,v1,v2);
   printf("深度優先搜索的結果:\n");
   DFSTraverse(g,visit);
   printf("廣度優先搜索的結果:\n");
   BFSTraverse(g,visit);
   printf("刪除一條邊或弧，請輸入待刪除邊或弧的弧尾 弧頭：");
   scanf("%s%s",v1,v2);
   DeleteArc(&g,v1,v2);
   Display(g);
   DestroyGraph(&g);
   printf("請順序選擇有向圖,有向網,無向圖,無向網\n");
   for(i=0;i<4;i++) /* 驗證4種狀況 */
   {
     CreateGraph(&g);
     Display(g);
     printf("插入新頂點，請輸入頂點的值: ");
     scanf("%s",v1);
     InsertVex(&g,v1);
     printf("插入與新頂點有關的弧或邊，請輸入弧或邊數: ");
     scanf("%d",&n);
     for(k=0;k<n;k++)
     {
       printf("請輸入另外一頂點的值: ");
       scanf("%s",v2);
       if(g.kind<=1) /* 有向 */
       {
         printf("對於有向圖或網，請輸入另外一頂點的方向(0:弧頭 1:弧尾): ");
         scanf("%d",&j);
         if(j)
           InsertArc(&g,v2,v1);
         else
           InsertArc(&g,v1,v2);
       }
       else /* 無向 */
         InsertArc(&g,v1,v2);
     }
     Display(g);
     printf("刪除頂點及相關的弧或邊，請輸入頂點的值: ");
     scanf("%s",v1);
     DeleteVex(&g,v1);
     Display(g);
     DestroyGraph(&g);
   }
 }