第十二周项目1-图基本算法库

/*   

* 烟台大学计算机与控制工程学院   

* 作者：王雪松  

* 完成日期：2016年11月18日   

*   

* 问题描述：图的存储结构主要包括邻接矩阵和邻接表，本算法库提供存储结构的定义，以及用于构造图存储结构、不同结构的转换及显示的代码。算法库采用程序的多文件组织形式，包括两个文件：

* 输入描述：

* 程序输出：

 */ 

代码：

　　1.头文件：graph.h，包含定义图数据结构的代码、宏定义、要实现算法的函数的声明；

 #ifndef GRAPH_H_INCLUDED
 #define GRAPH_H_INCLUDED

 #define MAXV 100                //最大顶点个数
 #define INF 32767       //INF表示∞
 typedef int InfoType;

 //以下定义邻接矩阵类型
 typedef struct
 {
     int no;                     //顶点编号
     InfoType info;              //顶点其他信息，在此存放带权图权值
 } VertexType;                   //顶点类型

 typedef struct                  //图的定义
 {
     int edges[MAXV][MAXV];      //邻接矩阵
     int n,e;                    //顶点数，弧数
     VertexType vexs[MAXV];      //存放顶点信息
 } MGraph;                       //图的邻接矩阵类型

 //以下定义邻接表类型
 typedef struct ANode            //弧的结点结构类型
 {
     int adjvex;                 //该弧的终点位置
     struct ANode *nextarc;      //指向下一条弧的指针
     InfoType info;              //该弧的相关信息,这里用于存放权值
 } ArcNode;

 typedef int Vertex;

 typedef struct Vnode            //邻接表头结点的类型
 {
     Vertex data;                //顶点信息
     int count;                  //存放顶点入度,只在拓扑排序中用
     ArcNode *firstarc;          //指向第一条弧
 } VNode;

 typedef VNode AdjList[MAXV];    //AdjList是邻接表类型

 typedef struct
 {
     AdjList adjlist;            //邻接表
     int n,e;                    //图中顶点数n和边数e
 } ALGraph;                      //图的邻接表类型

 //功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
 //参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
 //      n - 矩阵的阶数
 //      g - 要构造出来的邻接矩阵数据结构
 void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵
 void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表
 void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G
 void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g
 void DispMat(MGraph g);//输出邻接矩阵g
 void DispAdj(ALGraph *G);//输出邻接表G

 #endif // GRAPH_H_INCLUDED

 

　　2.源文件：graph.cpp，包含实现各种算法的函数的定义

 #include
 #include
 #include "graph.h"

 //功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
 //参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
 //      n - 矩阵的阶数
 //      g - 要构造出来的邻接矩阵数据结构
 void ArrayToMat(int *Arr, int n, MGraph &g)
 {
     int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
     g.n=n;
     for (i=0; i
         for (j=0; j
         {
             g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]，计算存储位置的功夫在此应用
             if(g.edges[i][j]!=0)
                 count++;
         }
     g.e=count;
 }

 void ArrayToList(int *Arr, int n, ALGraph *&G)
 {
     int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
     ArcNode *p;
     G=(ALGraph *)malloc(sizeof(ALGraph));
     G->n=n;
     for (i=0; i//给邻接表中所有头节点的指针域置初值
         G->adjlist[i].firstarc=NULL;
     for (i=0; i//检查邻接矩阵中每个元素
         for (j=n-1; j>=0; j--)
             if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
             {
                 p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                 p->adjvex=j;
                 p->info=Arr[i*n+j];
                 p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                 G->adjlist[i].firstarc=p;
             }

     G->e=count;
 }

 void MatToList(MGraph g, ALGraph *&G)
 //将邻接矩阵g转换成邻接表G
 {
     int i,j;
     ArcNode *p;
     G=(ALGraph *)malloc(sizeof(ALGraph));
     for (i=0; i//给邻接表中所有头节点的指针域置初值
         G->adjlist[i].firstarc=NULL;
     for (i=0; i//检查邻接矩阵中每个元素
         for (j=g.n-1; j>=0; j--)
             if (g.edges[i][j]!=0)       //存在一条边
             {
                 p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                 p->adjvex=j;
                 p->info=g.edges[i][j];
                 p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                 G->adjlist[i].firstarc=p;
             }
     G->n=g.n;
     G->e=g.e;
 }

 void ListToMat(ALGraph *G,MGraph &g)
 //将邻接表G转换成邻接矩阵g
 {
     int i,j;
     ArcNode *p;
     for (i=0; i//先初始化邻接矩阵
         for (j=0; j
             g.edges[i][j]=0;
     for (i=0; in; i++)  //根据邻接表，为邻接矩阵赋值
     {
         p=G->adjlist[i].firstarc;
         while (p!=NULL)
         {
             g.edges[i][p->adjvex]=p->info;
             p=p->nextarc;
         }
     }
     g.n=G->n;
     g.e=G->e;
 }

 void DispMat(MGraph g)
 //输出邻接矩阵g
 {
     int i,j;
     for (i=0; i
     {
         for (j=0; j
             if (g.edges[i][j]==INF)
                 printf("%3s","∞");
             else
                 printf("%3d",g.edges[i][j]);
         printf("\n");
     }
 }

 void DispAdj(ALGraph *G)
 //输出邻接表G
 {
     int i;
     ArcNode *p;
     for (i=0; in; i++)
     {
         p=G->adjlist[i].firstarc;
         printf("%3d: ",i);
         while (p!=NULL)
         {
             printf("-->%d/%d ",p->adjvex,p->info);
             p=p->nextarc;
         }
         printf("\n");
     }
 }

   

     3.在同一项目（project）中建立一个源文件(如main.cpp)，编制main函数，完成相关的测试工作。 例：

 #include
 #include
 #include "graph.h"

 int main()
 {
     MGraph g1,g2;
     ALGraph *G1,*G2;
     int A[6][6]=
     {
         {0,5,0,7,0,0},
         {0,0,4,0,0,0},
         {8,0,0,0,0,9},
         {0,0,5,0,0,6},
         {0,0,0,5,0,0},
         {3,0,0,0,1,0}
     };

     ArrayToMat(A[0], 6, g1);  //取二维数组的起始地址作实参，用A[0]，因其实质为一维数组地址，与形参匹配
     printf(" 有向图g1的邻接矩阵:\n");
     DispMat(g1);

     ArrayToList(A[0], 6, G1);
     printf(" 有向图G1的邻接表:\n");
     DispAdj(G1);

     MatToList(g1,G2);
     printf(" 图g1的邻接矩阵转换成邻接表G2:\n");
     DispAdj(G2);

  /*   ListToMat(G1,g2);
     printf(" 图G1的邻接表转换成邻接矩阵g2:\n");
     DispMat(g2);
     printf("\n");
     return 0;*/
 }

运行结果：