图-指尖上的舞蹈

·背景

在大部分数据结构的讲义中，图一般出现在第7章。可惜当年没好好学，现在重新拿出来啃一遍。印象中不少老师对于该章节都填鸭式的带过或者摆在最后开讲，也许因为当年LBS并不流行。在其章节后的是一些排序和管理，但就概念复杂度或者封装流行度而言，图还是更难一点。如果仅靠伪代码，需要更长的时间来消化。图，也许就像游戏中的最终BOSS一样，其恐惧、神秘、优雅、传说还是吸引着众多Fans们趋之若鹜。这两天边回忆、边吃饭、边吐血、边洗澡把最常用的一些观点重新笔记下来，但其实也只是冰山一角。

·分解

    历经百年，图的构成和运用已经遍布生活，其中欧洲人对于这块的贡献最大。整个图衍生出多个发展方向，如下图所示：

 

底层的图是一个大概念，如果没什么特别需求，可以理解就是我们的地图，只不过它更原始一点，更苍白一点，就一些线和点。

往上一层，分解出了有向、无向。也就是有没有箭头的区别，单行道、双行道的区别。

往上一层，分解出了权值。也就是这条路好不好走，要花多大代价走这条路。

往上一层，分解出了基于图应用算法。有一些基本的算法其实是通用的，笔者就目前流行的趋势稍微归一下类。

·基本遍历：DFS、BFS。一个按前序遍历，一个按层序遍历。帮助入门，缺点上：凡是遍历过的不再触碰，容易导致变形数。

·最小生成树：Prim、Kruskal。经常会听搞网络的同学说起，当然听到这个词语的时候，但后面两个名词很少听到，其实就是它们。一般来说，听到时候，多数是有人插错网线成环了。

·最短路径：Dijkstra。名字很难念，很多应用的看家法宝。其他还有一些算法就不举例了。缺点上，一般只给了结果，要想知道过程（路由明细），还需要再加工。

·强连通：Tarjen。一个找强连通的分量的算法，两两互联称为强连通。但具体能干什么用，还没想通，分类？机学？后续待研究。

·图匹配：匈牙利算法：二分图的最大匹配常用算法，同上，后续待研究。

·前三项算法的举例

原理就不多写了，网上都有，这里就边贴代码边分析。

·DFS：

       

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <typeinfo>
#include <set>
#include <stack>


using namespace std;

typedef string VertexType;                //顶点类型应由用户定义
typedef int EdgeType;                   //边上的权值类型应由用户定义
typedef int Boolean;
 
                               //最大顶点数，应由用户定义
#define INF  -1       //用-1来代表无穷大
#define DEBUG
#define TRUE 1
#define FALSE 0


typedef struct
{
   VertexType vexs[5];            //顶点表
   EdgeType   arc[5][5];     //邻接矩阵，可看作边
   int numVertexes, numEdges;          //图中当前的顶点数和边数
} Graph;

typedef struct
{
  char d1[2];
  char d2[2];
  int    wv;
} Wing;

typedef struct
{
  vector<string> v1;
  vector<string> v2;
  vector<int>    v3;
} Route;

Boolean visited[5];        //访问标志数组
Route *r;                  //路由表
int rp=0;                  //路由表长度
stack<string> minroute;    //最短路径栈


int locates(Graph *g, string sch);
void init(Graph *g);
void printGraph(Graph g);
void CreateGraph(Graph *g,Wing *ww,vector<string> &v);
void DFS(Graph g, int i,vector<string> &v);
void DFSclear(Graph g,vector<string> &v);
void DFSR(Graph g, int i, vector<string> &v,Route *r,stack<string> &stk);


int main()
{
   //放原始图
   Wing *w=NULL;
   w=(Wing*)malloc(sizeof(Wing)*6);


   //读原始图
   std::ios::sync_with_stdio(false);
   string line;
   string filename="./tu004.cfg";
   ifstream ifs;
   ifs.open(filename.c_str());
   int i=0;
   set<string> v2;
   vector<string> v1;  //遍历线序
   while(getline(ifs,line))
   {
          istringstream strstm(line);
          string str1,str2,str3;
          strstm>>str1>>str2>>str3;
          strcpy((w+i)->d1,str1.c_str());
          strcpy((w+i)->d2,str2.c_str());
          (w+i)->wv=atoi(str3.c_str());
          v2.insert(str1);
          v2.insert(str2);
          i++;
   }

   //邻接矩阵创建图和顶点数组枚举创建
   Graph g;
   
   set<string>::iterator v2_it;
   for(v2_it=v2.begin();v2_it!=v2.end();v2_it++)
   {
         v1.push_back(*v2_it);
   }

   //设置顶点和边上限
   g.numVertexes=5;
   g.numEdges=6;
   
   //开始干活
   init(&g);
   CreateGraph(&g,w,v1);
   printGraph(g);

   //结束
   free(w);

   //DFS 深度优先全遍历
   /*
   for(int i=0;i<5;i++)
   {
                DFSclear(g,v1);
                DFS(g,i,v1);
                for(int j=0;j<5;j++)
                        cout<<v1[j]<<" ";
                cout<<"---------------------------------------------------------------------"<<endl;

   }
   */

   //DFS 深度优先，输出路由表
   r=(Route*)malloc(sizeof(Route)*6);
   DFSclear(g,v1);
   DFSR(g,2,v1,r,minroute);
   for(int j=0;j<5;j++)
      cout<<v1[j]<<" ";
   cout<<"
---------------------------------------------------------------------"<<endl;

   //打印路由表
   for(int j=0;j<rp;j++)
           cout<<r->v1[j]<<":"<<r->v2[j]<<":"<<r->v3[j]<<endl;

   cout<<"
---------------------------------------------------------------------"<<endl;

   //打印最短路径
    while(minroute.size()>0)
    { 
                cout<<minroute.top()<<endl;
                minroute.pop();
        }
}


void DFSR(Graph g, int i, vector<string> &v,Route *r, stack<string> &stk)
{
   cout<<"进入遍历中"<<i<<":";
   stk.push(g.vexs[i]);
   v.push_back(g.vexs[i]);
   int j;
   visited[i] = TRUE;
   cout<<" 顶点:"<<g.vexs[i]<<endl;
   for(j = 0; j < g.numVertexes; j++)
   {
       cout<<"	遍历点:"<<j<<"的状态"<<visited[j]<<" "<<"g.arc的值"<<g.arc[i][j]<<endl;
       if(g.arc[i][j] == 1 && !visited[j])
       {
           cout<<"				   准备进入下一点:"<<j<<endl;
           cout<<"						 "<<i<<":"<<j<<":"<<g.arc[i][j]<<endl;
                   r->v1.push_back(g.vexs[i]);
                   r->v2.push_back(g.vexs[j]);
                   r->v3.push_back(g.arc[i][j]);
                   rp++;
           DFSR(g,j,v,r,stk);                  //对为访问的邻接顶点递归调用
       }
    }
    if(stk.top()=="3")
        {
      cout<<"完成最短路径"<<endl;
        }
        else
        {
                stk.pop();
        }
    cout<<"结束本次"<<i<<"遍历"<<endl;
}



void DFS(Graph g, int i, vector<string> &v)
{
   cout<<"进入遍历中"<<i<<":";
   v.push_back(g.vexs[i]);
   int j;
   visited[i] = TRUE;
   cout<<" 顶点:"<<g.vexs[i]<<endl;
   //printf("%s ", g.vexs[i].c_str());                           //打印顶点，也可以其他操作
   for(j = 0; j < g.numVertexes; j++)
   {
           cout<<"	遍历点:"<<j<<"的状态"<<visited[j]<<" "<<"g.arc的值"<<g.arc[i][j]<<endl;
       if(g.arc[i][j] == 1 && !visited[j])
       {
                  cout<<"				   准备进入下一点:"<<j<<endl;
                  cout<<"						 "<<i<<":"<<j<<":"<<g.arc[i][j]<<endl;
          DFS(g,j,v);                  //对为访问的邻接顶点递归调用
       }
   }
   cout<<"结束本次"<<i<<"遍历"<<endl;
}





void DFSclear(Graph g,vector<string> &v)
{
    int i;
        cout<<endl;
        cout<<"初始化所有顶点状态都是未访问过状态"<<endl;
    for(i = 0; i < g.numVertexes; i++)
    {
       visited[i] = FALSE;         //初始化所有顶点状态都是未访问过状态
    }
        v.clear();
}




void CreateGraph(Graph *g,Wing *ww,vector<string> &v)
{
        printf("刚才输入顶点数和边数为:%d %d
", g->numVertexes, g->numEdges);
    //设置顶点数组
        for(int i=0;i<g->numVertexes;i++)
        {
                 g->vexs[i]=v[i];
                 cout<<g->vexs[i]<<" ";
                 //printf("%s ",g->vexs[i].c_str());
        }     
        cout<<endl;


        //矩阵赋值
        for(int k=0;k<6;k++)
        {
                int m=-1;
                int n=-1;
                m = locates(g,(ww+k)->d1);
                n = locates(g,(ww+k)->d2);

        if(n == -1 || m == -1)
            {
               fprintf(stderr, "there is no this vertex.
");
               return;
            }
            //printf("m=%d,n=%d
",m,n);
            g->arc[m][n] = (ww+k)->wv;
            g->arc[n][m] = g->arc[m][n]; 
        }

}

void init(Graph *g)
{
        for(int i=0;i<g->numVertexes;i++)
                for(int j=0;j<g->numVertexes;j++)
                {
                  g->arc[i][j]=0;
                }
}



int locates(Graph *g,string sch)
{
   int i = 0;
   for(i = 0; i < g->numVertexes; i++)
   {
     if(g->vexs[i] == sch)
     {
         break;
     }
   }
   if(i >= g->numVertexes)
   {
        return -1;
    }
   return i;
}

void printGraph(Graph g)
{
  printf("开始打印
");
  int i, j;
  for(i = 0; i < g.numVertexes; i++)
  {
        for(j = 0; j < g.numVertexes; j++)
        {
          printf("%d  ", g.arc[i][j]);
         }
      printf("
");
  }
}

 结果：

 =================================================================================

·Prim：

       

原Prim算法中用的For遍历，我稍微改了一下，走嵌套，每个次只选择两个分支最为待选拓扑分支。

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <typeinfo>
#include <set>
#include <stack>
#include <map>



using namespace std;

typedef string VertexType;                //顶点类型应由用户定义
typedef int EdgeType;                   //边上的权值类型应由用户定义
typedef int Boolean;
 
#define DM 6           //顶点数
#define WM 8           //边数
#define INF  -1       //用-1来代表无穷大
#define DEBUG
#define TRUE 1
#define FALSE 0


typedef struct
{
   VertexType vexs[DM];            //顶点表
   EdgeType   arc[DM][DM];     //邻接矩阵，可看作边
   int numVertexes, numEdges;          //图中当前的顶点数和边数
} Graph;

typedef struct
{
  char d1[2];
  char d2[2];
  int    wv;
} Wing;

typedef struct
{
  vector<string> v1;
  vector<string> v2;
  vector<int>    v3;
} Route;

Boolean visited[DM];        //访问标志数组
Route *r;                  //路由表
int rp=0;                  //路由表长度
stack<string> mrs;    //最短路径栈


int locates(Graph *g, string sch);
void init(Graph *g);
void printGraph(Graph g);
void CreateGraph(Graph *g,Wing *ww,vector<string> &v);
void DFS(Graph g, int i,vector<string> &v);
void DFSclear(Graph g,vector<string> &v);
void DFSR(Graph g, int i, vector<string> &v,Route *r,stack<string> &stk);
void Prim(Graph g,int i);


int main()
{
   //放原始图
   Wing *w=NULL;
   w=(Wing*)malloc(sizeof(Wing)*8);


   //读原始图
   std::ios::sync_with_stdio(false);
   string line;
   string filename="./tu007.cfg";
   ifstream ifs;
   ifs.open(filename.c_str());
   int i=0;
   set<string> v2;
   vector<string> v1;  //遍历线序
   while(getline(ifs,line))
   {
          istringstream strstm(line);
          string str1,str2,str3;
          strstm>>str1>>str2>>str3;
          strcpy((w+i)->d1,str1.c_str());
          strcpy((w+i)->d2,str2.c_str());
          (w+i)->wv=atoi(str3.c_str());
          v2.insert(str1);
          v2.insert(str2);
          i++;
   }

   //邻接矩阵创建图和顶点数组枚举创建
   Graph g;
   
   set<string>::iterator v2_it;
   for(v2_it=v2.begin();v2_it!=v2.end();v2_it++)
   {
         v1.push_back(*v2_it);
   }

   //设置顶点和边上限
   g.numVertexes=DM;
   g.numEdges=WM;
   
   //开始干活
   init(&g);
   CreateGraph(&g,w,v1);
   printGraph(g);

   //结束
   free(w);

   //开始Prim算法
   DFSclear(g,v1);
   Prim(g,2);
}


void Prim(Graph g,int i)
{
    cout<<"进入遍历中"<<i<<":"<<endl;     
        visited[i] = TRUE;
        int mn=999;
        map<int,int> a;
        for(int j = 0; j < g.numVertexes; j++)
        {
           cout<<visited[j]<<" ";
           if(g.arc[i][j]>0 && !visited[j])
       {
             a[g.arc[i][j]]=j;     
           }
        }
        map<int,int>::iterator a_it=a.begin();

        cout<<endl;
        for(a_it;a_it!=a.end();a_it++)
        {
           cout<<"*权值列表="<<a_it->first<<" NEXT:"<<a_it->second<<endl;
        }

        a_it=a.begin();

        cout<<"	权值="<<a_it->first<<" NEXT:"<<a_it->second<<" MAP SIZE:"<<a.size()<<endl;

    if(a.size()>0)
        {
                if(a_it->first>0 && !visited[a_it->second])
                {
                        cout<<"	进入下一步:"<<a_it->second<<endl;
                        Prim(g,a_it->second);
                }
                a_it++;
                if(a_it->first>0 && !visited[a_it->second])
                {
                        cout<<"	进入下一步:"<<a_it->second<<endl;
                         Prim(g,a_it->second);
                }
        }

            cout<<"开始返回:"<<i<<endl;
}


void DFSR(Graph g, int i, vector<string> &v,Route *r, stack<string> &stk)
{
   cout<<"进入遍历中"<<i<<":";
   stk.push(g.vexs[i]);
   v.push_back(g.vexs[i]);
   int j;
   visited[i] = TRUE;
   cout<<" 顶点:"<<g.vexs[i]<<endl;
   for(j = 0; j < g.numVertexes; j++)
   {
       cout<<"	遍历点:"<<j<<"的状态"<<visited[j]<<" "<<"g.arc的值"<<g.arc[i][j]<<endl;
       if(g.arc[i][j] == 1 && !visited[j])
           //if(g.arc[i][j] == 1 )
       {
           cout<<"				   准备进入下一点:"<<j<<endl;
           cout<<"						  "<<i<<":"<<j<<":"<<g.arc[i][j]<<endl;
                   r->v1.push_back(g.vexs[i]);
                   r->v2.push_back(g.vexs[j]);
                   r->v3.push_back(g.arc[i][j]);
                   rp++;
           DFSR(g,j,v,r,stk);                  //对为访问的邻接顶点递归调用
       }
    }
  
    if(stk.top()=="5")
        {
      cout<<"完成最短路径"<<endl;
        }
        else
        {
                stk.pop();
        }
    cout<<"结束本次"<<i<<"遍历"<<endl;
    
}



void DFS(Graph g, int i, vector<string> &v)
{
   cout<<"进入遍历中"<<i<<":";
   v.push_back(g.vexs[i]);
   int j;
   visited[i] = TRUE;
   cout<<" 顶点:"<<g.vexs[i]<<endl;
   //printf("%s ", g.vexs[i].c_str());                           //打印顶点，也可以其他操作
   for(j = 0; j < g.numVertexes; j++)
   {
           cout<<"	遍历点:"<<j<<"的状态"<<visited[j]<<" "<<"g.arc的值"<<g.arc[i][j]<<endl;
       if(g.arc[i][j] == 1 && !visited[j])
       {
                  cout<<"				   准备进入下一点:"<<j<<endl;
                  cout<<"						 "<<i<<":"<<j<<":"<<g.arc[i][j]<<endl;
          DFS(g,j,v);                  //对为访问的邻接顶点递归调用
       }
   }
   cout<<"结束本次"<<i<<"遍历"<<endl;
}





void DFSclear(Graph g,vector<string> &v)
{
    int i;
        cout<<endl;
        cout<<"初始化所有顶点状态都是未访问过状态...."<<endl;
    for(i = 0; i < g.numVertexes; i++)
    {
       visited[i] = FALSE;         //初始化所有顶点状态都是未访问过状态
    }
        v.clear();
}




void CreateGraph(Graph *g,Wing *ww,vector<string> &v)
{
        #ifdef DEBUG
             printf("刚才输入顶点数和边数为:%d %d
", g->numVertexes, g->numEdges);
        #endif
    //设置顶点数组
        for(int i=0;i<g->numVertexes;i++)
        {
                 g->vexs[i]=v[i];
                 cout<<g->vexs[i]<<" ";
                 //printf("%s ",g->vexs[i].c_str());
        }     
        cout<<endl;


        //矩阵赋值
        for(int k=0;k<WM;k++)
        {
                int m=-1;
                int n=-1;
                m = locates(g,(ww+k)->d1);
                n = locates(g,(ww+k)->d2);

        if(n == -1 || m == -1)
            {
               fprintf(stderr, "there is no this vertex.
");
               return;
            }
            //printf("m=%d,n=%d
",m,n);
            g->arc[m][n] = (ww+k)->wv;
            g->arc[n][m] = g->arc[m][n]; 
        }

}

void init(Graph *g)
{
        for(int i=0;i<g->numVertexes;i++)
                for(int j=0;j<g->numVertexes;j++)
                {
                  g->arc[i][j]=0;
                }
}



int locates(Graph *g,string sch)
{
   int i = 0;
   for(i = 0; i < g->numVertexes; i++)
   {
     if(g->vexs[i] == sch)
     {
         break;
     }
   }
   if(i >= g->numVertexes)
   {
        return -1;
    }
   return i;
}

void printGraph(Graph g)
{
  printf("开始打印
");
  int i, j;
  for(i = 0; i < g.numVertexes; i++)
  {
        for(j = 0; j < g.numVertexes; j++)
        {
          printf("%d  ", g.arc[i][j]);
         }
      printf("
");
  }
}

结果：

=================================================================================

·Dijkstra：

  

原Dijkstra算法实现，只打印了最短路径结果，但个人觉得中间过程明细更重要，稍微改了一下。

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <typeinfo>
#include <set>


using namespace std;

typedef string VertexType;                //顶点类型应由用户定义
typedef int EdgeType;                   //边上的权值类型应由用户定义
 
#define  DM 6           //顶点数
#define  BM 8           //边数
#define INF   9999999       //用9999999来代表无穷大
#define DEBUG


typedef struct
{
   VertexType vexs[DM];            //顶点表
   EdgeType   arc[DM][DM];     //邻接矩阵，可看作边
   int numVertexes, numEdges;          //图中当前的顶点数和边数
} Graph;

typedef struct
{
  char d1[2];
  char d2[2];
  int    wv;
} Wing;

typedef struct 
{
    int r_id;
        int src;
        int des;
        double  ww;
} Rd;

int locates(Graph *g, string sch);
void init(Graph *g);
void printGraph(Graph g);
void CreateGraph(Graph *g,Wing *ww,vector<string> &v);
void DIJ(Graph g,int src,Rd rtt[]);

int main()
{
   //放原始图
   Wing *w=NULL;
   w=(Wing*)malloc(sizeof(Wing)*BM);


   //读原始图
   std::ios::sync_with_stdio(false);
   string line;
   string filename="./tu008.cfg";
   ifstream ifs;
   ifs.open(filename.c_str());
   int i=0;
   set<string> v2;
   while(getline(ifs,line))
   {
          istringstream strstm(line);
          string str1,str2,str3;
          strstm>>str1>>str2>>str3;
          strcpy((w+i)->d1,str1.c_str());
          strcpy((w+i)->d2,str2.c_str());
          (w+i)->wv=atoi(str3.c_str());
          v2.insert(str1);
          v2.insert(str2);
          i++;
   }

   //邻接矩阵创建图和顶点数组枚举创建
   Graph g;
   vector<string> v1;

   set<string>::iterator v2_it;
   for(v2_it=v2.begin();v2_it!=v2.end();v2_it++)
   {
         v1.push_back(*v2_it);
   }

   //设置顶点和边上限
   g.numVertexes=DM;
   g.numEdges=BM;
   
   //开始干活
   init(&g);
   CreateGraph(&g,w,v1);
   printGraph(g);

   //结束
   free(w);

   //拓扑最短路径
   Rd route[10];
   DIJ(g,0,route);
   
}


void DIJ(Graph g, int src,Rd rtt[])
{
    int idMin = 0;
        double dMin = 0;
        double dTempMin = 0;
        int rtc=0;  //路由表计数
    
        //距离定义,访问标记
        double dDist[DM] = {0};
        bool bFinalSet[DM] = {false};

        for (int i=0;i<DM;i++)
    {
            bFinalSet[i] = false;
        dDist[i] = g.arc[src][i];
                //cout<<i<<":"<<bFinalSet[i]<<":"<<dDist[i]<<endl;
                cout<<"Route Detail:"<<src<<"-->"<<i<<","<<dDist[i]<<endl;
                //初始化路由表

                rtt[i].r_id=i;
                rtt[i].src=src;
                rtt[i].des=i;
                rtt[i].ww=dDist[i];
                rtc=i;

    }
    
        cout<<endl;

    //起点定义
        dDist[src]= 0;
        bFinalSet[src] = true;

    for (int j=1;j<DM;j++)
        {
                //打印路由表
                cout<<"打印路由表共"<<rtc+1<<"条:"<<endl;
                for(int z=0;z<=rtc;z++)
                {
                        cout<<rtt[z].r_id<<":"<<rtt[z].src<<":"<<rtt[z].des<<":"<<rtt[z].ww<<endl;
                }

        //开始遍历
                dMin = INF;
                cout<<"--------------------------------"<<endl;
                for (int k=0; k<DM;k++)
                {
                     if ((!bFinalSet[k]) && (dDist[k] <= dMin))
                     {  
                            cout<<"Round:"<<j<<"|k="<<k<<" dDist["<<k<<"]="<<dDist[k]<<endl;
                        idMin = k;
                        dMin = dDist[k];
                     }
                }
            bFinalSet[idMin] = true;
                cout<<"Round:"<<j<<"|最短路径 "<<src<<" and idMin="<<idMin<<" is:dMin="<<dMin<<endl;
        
            for (int l=0;l<DM;l++)
                {
                     dTempMin = dMin + g.arc[idMin][l];
                //       cout<<"Round:"<<j<<"|g.arc["<<idMin<<"]["<<l<<"]:"<<g.arc[idMin][l]<<"|dTempMin:"<<dTempMin<<"|dDist["<<l<<"]:"<<dDist[l]<<endl;
             if ((!bFinalSet[l]) && (dTempMin < dDist[l]))
             {
                               rtc++;
                                   rtt[rtc]=rtt[idMin];
                                   rtt[rtc].r_id=rtc;
                                   rtt[rtc].src=idMin;
                                   rtt[rtc].des=l;
                                   rtt[rtc].ww=dTempMin;
                                   cout<<"Round:"<<j<<"|Update dDist["<<l<<"],Route Detail "<<idMin<<"--->"<<l<<endl;
                       dDist[l] = dTempMin;
             }
                         //cout<<"Round:"<<j<<"|Update ShortPath dDist["<<l<<"]:"<<dDist[l]<<endl;
        }


        }
}

void CreateGraph(Graph *g,Wing *ww,vector<string> &v)
{
        #ifdef DEBUG
             printf("刚才输入顶点数和边数为:%d %d
", g->numVertexes, g->numEdges);
        #endif
    //设置顶点数组
        for(int i=0;i<g->numVertexes;i++)
        {
                 g->vexs[i]=v[i];
                 cout<<g->vexs[i]<<" ";
        }     
        cout<<endl;


        //矩阵赋值
        for(int k=0;k<BM;k++)
        {
                int m=-1;
                int n=-1;
                m = locates(g,(ww+k)->d1);
                n = locates(g,(ww+k)->d2);

        if(n == -1 || m == -1)
            {
               fprintf(stderr, "there is no this vertex.
");
               return;
            }
            //printf("m=%d,n=%d
",m,n);
            g->arc[m][n] = (ww+k)->wv;
           // g->arc[n][m] = g->arc[m][n]; 
        }

}

void init(Graph *g)
{
        for(int i=0;i<g->numVertexes;i++)
                for(int j=0;j<g->numVertexes;j++)
                {
                  if(i==j)
                  {
                  g->arc[i][j]=0;
                  }
                  else
                  {
                  g->arc[i][j]=INF;
                  }
                }
}



int locates(Graph *g,string sch)
{
   int i = 0;
   for(i = 0; i < g->numVertexes; i++)
   {
     if(g->vexs[i] == sch)
     {
         break;
     }
   }
   if(i >= g->numVertexes)
   {
        return -1;
    }
   return i;
}

void printGraph(Graph g)
{
  printf("开始打印
");
  int i, j;
  for(i = 0; i < g.numVertexes; i++)
  {
        for(j = 0; j < g.numVertexes; j++)
        {
          printf("%8d  ", g.arc[i][j]);
         }
      printf("
");
  }
}

结果：

·小结

　　上述这些只是近期无聊研究的结果，大家伙轻拍砖~，^_^ ，午睡去了