山东大学数据结构实验七：图的基本操作---c++实现---超详细注释

山东大学数据结构实验七：图的基本操作—c++实现

内含方法：
结构体定义图的邻接矩阵，结构体定义队列，队列初始化，出队，入队方法，邻接矩阵初始化，BFS（广度优先搜索）遍历图，DFS（深度优先搜索）遍历图，Floyed方法-----求各顶点间的最短路径；

#include<iostream>
using namespace std;
#define MaxVnum 100//顶点数最大值
#define Maxsize 100//队列的最大值
typedef int VexType;//顶点类型数据，定义为int，根据需求自行定义
typedef int EdgeType;//边上的数据类型
int k=0;//记录与顶点v相邻接的所有点的个数
int i=0;//记录DFS方法中输出点的个数
//图的结构体定义（使用邻接矩阵）
typedef struct{
    VexType Vex[MaxVnum];//一维数组存储顶点信息
    EdgeType Edge[MaxVnum][MaxVnum];//邻接矩阵存储边信息，如果是网则存储的是边上的加权值，如果是图则存储的是0/1
    int vexnum,edgenum;//顶点数，边数
}AMGragh;
//队列的声明；队列从队尾入，从队头出；BFS方法用到了队列
typedef struct SqQueue
{
     int a[100];
    int front,rear;//front队头 rear队尾
}SqQueue;
//队列初始化
void Initsqqueue(SqQueue &Q)
{
    Q.front=Q.rear=0;
}
//顶点入队，从队尾入
void push(SqQueue &Q, int &x)
{
    Q.a[Q.rear]=x;//将x放入队列，Q.rear所指的空间
    Q.rear=(Q.rear+1)%Maxsize;//Q.rear后移一位，当rear大于Maxsize-1时，则把元素存放到第0位（循环队列）
}
//顶点出队，从队头出  
void pop(SqQueue &Q)
{   //front向后移一位
    Q.front=(Q.front+1)%Maxsize;
}
//邻接矩阵初始化
void CreateAMGraph (AMGragh &G,int v,int e)
{
int i,j;
int m=1;
VexType s,t;//起始点s，终点t
EdgeType n;//边的加权值n
//邻接矩阵初始化，从第一行第一列开始存储
for(int i=1;i<=v;i++)
for(int j=1;j<=v;j++)
   G.Edge[i][j]=0x3f3f3f3f;//网（边上是有加权值的）的初始化为无穷大，图的初始化为0
//一维顶点数组存储顶点信息，从G.Vex[1]开始存储，对应第一个顶点
for(int i=1;i<=v;i++)
{ //实验要求第一个顶点表示为1，第n个顶点表示为n
     G.Vex[i]=m;
     m++;
}
while(e!=0) //有多少边就要输出多少组数据（起点-终点-加权值）
{
 scanf("%d,%d,%d",&s,&t,&n); //使用scanf规定输入格式
 if(s>=0&&t>=0&&s<MaxVnum&&t<MaxVnum)
 {//因为是无向图，所以是对称矩阵，关于主对角线对称，有向图则不是对称矩阵
  G.Edge[s][t]=n;
  G.Edge[t][s]=n;
  }
  e--;//每输入一组数据，e-1，直到e==0，停止输入
}
}
// BFS_AM2(AMGragh &G,int v,int s)方法是为了得到与顶点v相邻接的所有顶点的个数k，便于后面的遍历输出
//此方法是下面BFS方法的变形，只不过不输出只为了得到k的值
void BFS_AM2(AMGragh &G,int v,int s)//v代表是从第几个节点开始遍历，从图中的第v个节点开始访问，s是顶点数G.vexnum
{
    int u,w;
    SqQueue Q;
    Initsqqueue(Q);//队列Q的初始化
     bool visited[s+1];//建立bool类型数组，用来记录节点是否被访问过，申请s+1的空间，从visited[1]开始存储，正好对应第一个节点
     for(int i=1;i<=s;i++)//visited数组初始化，每个节点都没有被访问过
     visited[i]=false;
     //先访问起始顶点v
    visited[v]=true;//v被访问完后，标记为true
    push(Q,v);//起始点v入队,使队列不为空
    while(Q.front!=Q.rear)//当队列Q不为空时，进入while循环
    {  
       u=Q.a[Q.front];// 使u=队头元素
       pop(Q);//队头元素出队
       for(w=1;w<=s;w++)//依次检查u的所有邻接点
       {
           if(G.Edge[u][w]!=0x3f3f3f3f&&visited[w]==false)//u,w邻接并且w并未被访问
           {     k++;//每找到一个邻接点w，k+1，那么直到最后出while循环，就可以得到与起始点v相邻接的所有点的个数k
               visited[w]=true;
               push(Q,w);//把与u邻接的点w放入队列中，便于后面找与w相邻接的其他点
           }
       }
    }
}
//广度优先搜索：从某个定点出发，一次性访问所有未被访问的邻接点，再依次从这些访问过的邻接点出发继续访问所有未被访问过的邻接点。。。
//算法步骤：
//1，初始化图中所有顶点均未被访问，初始化一个空队列
//2，从图中某个顶点v出发，访问v并标记已访问，将v入队
//3，v出队，找其邻接点，并将其所有邻接点入队，再反复重复2，3，直到队列为空
void BFS_AM(AMGragh &G,int v,int s)//v代表是第几个节点，从图中的第几个节点开始访问，s是顶点数G.vexnum
{
    int u,w,l=0;
    SqQueue Q;
    Initsqqueue(Q);//队列Q的初始化
     bool visited[s+1];//建立bool类型数组，用来记录节点是否被访问过，申请s+1的空间，从visited[1]开始存储，正好对应第一个节点
     for(int i=1;i<=s;i++)//visited数组初始化，每个节点都没有被访问过
     visited[i]=false;
     //先访问起始顶点v
    cout<<G.Vex[v]<<",";
    visited[v]=true;//被访问完后，标记为true
    push(Q,v);//起始点v入队,使队列不为空
    while(Q.front!=Q.rear)//当队列Q不为空时，进入while循环
    {  
       u=Q.a[Q.front];// 使u=队头元素
       pop(Q);//队头元素出队
       for(w=1;w<=s;w++)//依次检查u的所有邻接点
       {
           if(G.Edge[u][w]!=0x3f3f3f3f&&visited[w]==false)//u,w邻接并且w并未被访问
           {    l++;//使用l记录输出的是v的第几个邻接点
               if(l<k)//如果不是最后一个邻接点
               cout<<G.Vex[w]<<",";
               else//如果是最后一个邻接点
               cout<<G.Vex[w];
               //访问完需要标记为已访问
               visited[w]=true;
               push(Q,w);//把与u邻接的点w放入队列中，便于后面找与w相邻接的其他点
           }
       }
    }
}
//深度优先遍历：从一个顶点出发，访问其中一个邻接点，访问到尽头，再返回来访问另一个邻接点，访问到尽头；
//算法步骤
//1，起初，图中所有点均未被访问
//2，从图中某个顶点v出发，访问v，并标记已访问，visited[v]=true;
//3，依次检查v的所有邻接点w，如果w未被访问，则从w出发进行深度优先遍历（递归调用）直到没有邻接点为止
void DFS_AM(AMGragh &G,int v,int s, bool visited[])//v代表是第几个节点，从图中的第几个节点开始访问，s是顶点数G.vexnum
{
      int w;
      if(i<k)//如果不是最后一个邻接点
     cout<<G.Vex[v]<<",";//起始节点的访问
     else //如果是最后一个邻接点
     cout<<G.Vex[v];
    visited[v]=true;//被访问完后，标记为true
    //依次检查u的所有邻接点
    for(w=1;w<=s;w++)
    {
        if(G.Edge[v][w]!=0x3f3f3f3f&&visited[w]==false)//v,w邻接并且w并未被访问
        {    i++;//使用i记录访问的是v的第几个邻接点
            DFS_AM(G,w,s,visited);//找到w顶点后，以w为起始节点开始递归深度优先遍历，直到遍历到尽头，无邻接点为止，再返回
        }
    }
}
//求各顶点间的最短路径---Floyed
//算法步骤：1，初始化dist数组；2，插点：在i，j之间插入顶点k（实际就是从i到j能否借助中间点k）看能否缩短i和j之间的距离
int Floyd(AMGragh &G,int v)//v是顶点数
{
int i,j,k;
int dist[100][100];//dist数组是最短距离数组，dist[i][j]记录从i 节点到j节点的最短路径长
//dist数组初始化
for(int i=1;i<=v;i++)
 {
for(int j=1;j<=v;j++)
   {
    if(i==j)
    dist[i][j]=0;//规定顶点到顶点自己的路径长为0
    else
   dist[i][j]=G.Edge[i][j];
   }
 }
for(k=1;k<=v;k++)//从节点1开始，遍历至末尾节点，看能否做插入i，j之间的插点从而缩小从i到j的最短距离；
 //如果为无向图，只要顶点之间有边则就可以借助插点k
 //如果为有向图，事实上只有节点有入边才可以作为插点，但是计算机没办法判断是否有入边，所以只能从节点1开始遍历到末尾节点；如果没有入边则dist[i][k]，dist[k][j]二者其中必有一个无穷大
    for(i=1;i<=v;i++)
        for(j=1;j<=v;j++)
       if(dist[i][k]+dist[k][j]<dist[i][j])//从i经k到j的一条更短路径
       {
           dist[i][j]=dist[i][k]+dist[k][j];//更新dist[i][j]
       }
       //执行完上面的3个for循环，则dist数组已全部更新完成， dist[i][j]存储的是从i到j的最短路径长
       //根据实验要求，输出从1到末尾节点的最短路径
       if(dist[1][v]==0x3f3f3f3f)
       return 0;
       else 
       return dist[1][v];
}

int main()
{
    AMGragh G;
    int v=G.vexnum;//总的顶点数
    int e=G.edgenum;//总的边数
    cout<<"Input"<<endl;
    scanf("%d,%d",&v,&e); 
    CreateAMGraph (G,v,e);//创建无向图的邻接矩阵
    cout<<"Output"<<endl;
     BFS_AM2(G,1,v);//得到与1邻接的所有点的个数k
     BFS_AM(G,1,v);//BFS遍历与1邻接的所有点
    cout<<endl;
    bool visited[v+1];//建立bool类型数组，用来记录节点是否被访问过
    for(int i=1;i<=v;i++)//visited数组初始化，每个节点都没有被访问过
    visited[i]=false;
    DFS_AM(G,1,v,visited);//BFS遍历与1邻接的所有点
    cout<<endl;
    cout<<Floyd(G,v)<<endl;//输出从1到末尾节点的最短路径
    cout<<"End"<<endl;
    return 0;
}

欢迎大家指正！