数据结构_图_基本操作的c++实现

/*------------------------------------Graph--------图-------------------------*/
//邻接矩阵法存储图
//定义结构体
#define MaxVertexNum 100                         //顶点数目的最大值
typedef struct{
    char Vex[MaxVertexNum];                           //顶点表
    int Edge[MaxVertexNum][MaxVertexNum];             //邻接矩阵，边表
    int vexnum,arcnum;                               //图的当前顶点数和边数
}MGraph;

//邻接矩阵法存储带权图（网）
#define MaxVertexNum 100                         //顶点数目的最大值
#define INFINITY  最大的int值                    //宏定义常量“无穷”
typedef char VertexType;                        //顶点的数据类型
typedef int EdgeType;                           //带权图中边上权值的数据类型
typedef struct{
    VertexType Vex[MaxVertexNum];                //顶点
    EdgeType Edge[MaxVertexNum][MaxVertexNum];   //边的权
    int vexnum,arcnum;                           //图的当前顶点数和弧数
}MGraph_1;

//邻接表法（顺序+链式存储）-------------和树的孩子表示法相同
//定义结构体
//“边/弧”
typedef struct ArcNode{
    int adjvex;                   //边/弧指向哪个结点
    struct ArcNode *next;        //指向下一条弧的指针
    //InfoType info;              //边权值
}ArcNode;
//“顶点”
typedef struct VNode{
    VertexType data;        //顶点信息
    ArcNode *first;        //第一条边/弧指针
}VNode,AdjList[MaxVertexNum];             //AdjList[MaxVertexNum]表示具体有多少个结点
//用邻接表存储的图
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;


//十字链表法


//邻接多重表


//广度优先遍历（BFS）
bool visited[MaxVertexNum];             //访问标记数组
void BFSTraverse(MGraph G){           //对图G进行广度优先遍历
    for(int i=0;i<G.vexnum;i++)
        visited[i]=FALSE;              //访问标记数组初始化
    InitQueue(Q);                   //初始化辅助队列Q
    for(int i=0;i<G.vexnum;++i)        //从0号顶点开始遍历
        if(!visited[i])               //对每个连通分量调用一次BFS
            BFS(G,i);                //vi未访问过，从vi开始BFS
}          //!BFS(G,v)只能遍历连通图，所以还需加上BFSTraverse(G)
void BFS(Graph G,int v){                       //从顶点v出发，广度优先遍历图G
    visit(v);                               //访问初始顶点v
    visited[v]=TRUE;                          //对v做已访问标记
    EnQueue(Q,v);                              //顶点v入队列Q
    while(!isEmpty(Q)){
        DeQueue(Q,v);                          //顶点v出队列
        for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w))
            //检测v所有邻接点
        if(!visited[w]){                      //w为v的尚未访问的邻接顶点
            visit(w);                      //访问顶点w
            visited[w]=TRUE;                 //对w做已访问标记
            EnQueue(Q,w);                   //顶点w入队列
        }//if
    }//while
}


//深度优先遍历（DFS）
bool visited[MaxVertexNum];           //访问标记数组
void DFSTraverse(Graph G){              //对图G进行深度优先遍历
    for(int v=0;v<G.vexnum;++v)
        visited[v]=FALSE;            //初始化已访问标记数据
    for(int v=0;v<G.vexnum;++v)
        if(!visited[v])
        DFS(G,v);
}

void DFS(Graph G,int v){           //从顶点v出发，深度优先遍历图G
    visit(v);                      //访问顶点v
    visited[v]=TRUE;               //设已访问标记
    for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w))
    if(!visited[w]){                //w为u的尚未访问的邻接顶点
        DFS(G,w);
    }//if
}

/*----------------------BFS算法（无权图单源最短路径问题）-----------------*/
void BF_MIN_Distance(Graph G,int v){                       //从顶点v出发，广度优先遍历图G
    //d[i]表示从v到i结点的最短路径
    for(int i=0;i<G.vexnum;++i){
        d[i]=∞;             //初始化路径长度
        path[i]=-1;          //最短路径从哪个顶点过来
    }
    d[v]=0;                              //访问初始顶点v
    visited[v]=TRUE;                          //对v做已访问标记
    EnQueue(Q,v);                              //顶点v入队列Q
    while(!isEmpty(Q)){
        DeQueue(Q,v);                          //顶点v出队列
        for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w))
            //检测v所有邻接点
        if(!visited[w]){                      //w为v的尚未访问的邻接顶点
            d[w]=d[v]+1;
            path[w]=v;
            visited[w]=TRUE;                 //对w做已访问标记
            EnQueue(Q,w);                   //顶点w入队列
        }//if
    }//while
}

//Floyd算法
//……准备工作，根据图的信息初始化矩阵A和path
//三趟for循环