数据结构C++语言版 -- 图

catlv77
已于 2022-02-27 19:13:29 修改
阅读量349
点赞数
分类专栏：数据结构 -- C++ 文章标签：数据结构 c++ 开发语言
于 2022-02-27 19:08:21 首次发布
本文链接：https://blog.csdn.net/catlv77/article/details/123168501
版权
数据结构 -- C++ 专栏收录该内容
6 篇文章 0 订阅
订阅专栏
大二学生的 C++数据结构有部分Openjudge提交的代码没有删除
邮箱：liu_772021@yeah.net
欢迎交流讨论~
有用的话，点赞留言



#include <iostream>
#include <stdio.h>
#include <cstring>
#include <stdlib.h>
#include <math.h>
using namespace std;

//图中最大顶点数
#define MAXVEX 100

//定义无穷大值为 整型变量最大值
#define INF 2147483647

//全局变量length = 节点数（可以取MAXVEX，即最大顶点数）
const int length = 7;

//全局数组visited[]
static bool visited[MAXVEX];

//定义VertexType为字符串类型
typedef char VertexType[10];

//顶点类型
typedef struct vertex {
    //顶点编号
    int adjvex;
    //顶点信息
    VertexType data;
}VType;

//图的邻接矩阵类型
typedef struct graph {
    //n实际顶点数；e实际边数
    int n, e;
    //顶点集合
    VType vexs[MAXVEX];
    //边集合
    int edges[MAXVEX][MAXVEX];
}MatGraph;

//结构体声明：每个顶点建立的单链表中边结点的类型
typedef struct edgenode {
    //相邻点序号
    int adjvex;
    //边的权值
    int weight;
    //下一条边的顶点
    struct edgenode* nextarc;
}ArcNode;

//单链表头结点类型
typedef struct vexnode {
    //存放一个顶点的信息
    VertexType data;
    //指向第一条边的顶点
    ArcNode* firstarc;
} VHeadNode;
//描述一个顶点的基本数据和它相关边的信息

//图的邻接表类型
typedef struct {
    //n为实际顶点数，e为实际边数
    int n, e;
    //单链表头节点数组
    VHeadNode adjlist[MAXVEX];
}AdjGraph;

//建立图的 邻接矩阵
void CreateMatGraph(MatGraph& g, int A[][MAXVEX], int n, int e) {
    int i, j;
    //给图的顶点数、边数赋值
    g.n = n; g.e = e;
    
    //给图的边赋权重
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            g.edges[i][j] = A[i][j];
        }
    }
}

//销毁图 （系统自动释放内存）
void DestroyMatGraph(MatGraph g) {

}

//输出图（以邻接矩阵存储结构输出）（即输出的是一个邻接矩阵）
void DipsatGraph(MatGraph g) {
    int i, j;
    for (i = 0; i < g.n; i++) {
        for (j = 0; j < g.n; j++) {
            if (g.edges[i][j] < INF)
                printf("%4d", g.edges[i][j]);
            else
                printf("%4s", "∞");

        }
        printf("\n");
    }
}

//求顶点的度（无向图） v是顶点编号；通过查找邻接矩阵第v行的信息
//无向图G的度
int Degree_Mat1(MatGraph g, int v) {
    int i, d = 0;
    //输入顶点编号错误，返回-1；
    if (v < 0 || v >= g.n)
        return -1;
    //输入顶点编号正确：
        //统计第v行既不为0也不为INF的边数 即【度】
    for (i = 0; i < g.n; i++)
        if (g.edges[v][i] > 0 && g.edges[v][i] < INF)
            d++;
    return d;
}

//求顶点的度（有向图） v是顶点编号；通过查找邻接矩阵第v行的信息
//有向图G的度 = 入度 + 出度
//入度：以该点为中点的入边数目；出度：以该店为起点的出边数目
int Degree_Mat2(MatGraph g, int v) {
    int i, d_in = 0, d_out = 0, d_sum;
    //输入顶点编号错误，返回-1；
    if (v < 0 || v >= g.n)
        return -1;
    //输入顶点编号正确：
        //d1 出度统计
    for (i = 0; i < g.n; i++)
        if (g.edges[v][i] > 0 && g.edges[v][i] < INF)
            d_out++;
        //d2 入度统计
    for (i = 0; i < g.n; i++)
        if (g.edges[i][v] > 0 && g.edges[v][i] < INF)
            d_in++;
    //有向图的度 = 入度 + 出度
    d_sum = d_in + d_out;
    return d_sum;
}

//建立图的邻接表运算算法
//A是邻接矩阵数组，顶点数n，边数e
void CreateAdjGraph(AdjGraph*& G, int A[][MAXVEX], int n, int e) {
    int i, j;
    ArcNode* p;
    
    //申请AdjGraph的空间
    G = (AdjGraph*)malloc(sizeof(AdjGraph));
    
    //AdjGraph属性赋值
    G->n = n; G->e = e;
    
    //邻接表中所有的头结点的指针域置空（初始化）
    for (i = 0; i < G->n; i++)
        G->adjlist[i].firstarc = NULL;
    
    //检查A中每个元素
    for (i = 0; i < G->n; i++){
        for (j = G->n - 1; j >= 0; j--){
            //存在一条边
            if (A[i][j] > 0 && A[i][j] < INF) {
                //创建一个结点p
                p = (ArcNode*)malloc(sizeof(ArcNode));
                p->adjvex = j;//相邻点序号
                p->weight = A[i][j];//权值
                //头插法插入p
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
}

//销毁【邻接表】图运算算法
void DestroyAdjGraph(AdjGraph*& G) {
    int i;
    ArcNode* pre, * p;
    //遍历所有头结点
    for (i = 0; i < G->n; i++) {
        pre = G->adjlist[i].firstarc;
        if (pre != NULL) {
            p = pre->nextarc;
            //释放adjlist[j]的所有边结点空间
            while (p != NULL) {
                free(pre);
                pre = p; p = p->nextarc;
            }
            free(pre);
        }
    }
    //释放G所指的头结点数组的内存空间
    free(G);
}

//输出图的邻接表
void DispAdjGraph(AdjGraph* G) {
    ArcNode* p;
    int i;
    //便利所有头结点
    for (i = 0; i < G->n; i++) {
        printf(" [%2d]", i);
        p = G->adjlist[i].firstarc;
        if (p != NULL)
            printf("→");
        while (p != NULL) {
            printf(" % d(% d)", p->adjvex, p->weight);
            //p移向下一个相邻点
            p = p->nextarc;
        }
        printf("\n");
    }
}

//邻接表——无向图G中顶点v的度，v是顶点编号
int Degree_Adj1(AdjGraph *G,int v){
    int d = 0;
    ArcNode *p;
    
    //顶点编号错误,返回-1
    if(v<0 || v>=G->n){
        return -1;
    }
    p = G->adjlist[v].firstarc;
    //统计v顶点的单链表中边结点的个数
    while(p != NULL){
        d++;
        p = p->nextarc;
    }
    return d;
}

//邻接表——有向图G中顶点v的度，v-顶点编号
//稍加更改后，可以返回顶点的入度、出度
int Degree_Adj2(AdjGraph *G,int v){
    int i,d_in = 0,d_out = 0,d_sum;
    ArcNode *p;
    if(v<0 || v>=G->n){
        return -1;
    }
    p = G->adjlist[v].firstarc;
    
    //统计v定点的单链表中边结点个数，即【出度】
    while(p!=NULL){
        d_out++;
        p = p->nextarc;
    }
    
    //统计边结点中adjves为v的个数，即【入度】
    for(i = 0;i < G->n;i++){
        p = G->adjlist[i].firstarc;
        while(p != NULL){
            if(p->adjvex == v){
                d_in++;
            }
            p = p->nextarc;
        }
    }
    d_sum = d_in + d_out;
    return d_sum;
}

//邻接矩阵g 转换成 邻接表G
void MatToAdj(MatGraph g, AdjGraph*& G) {
    int i, j;
    ArcNode* p;
    //创建邻接表G
    G = (AdjGraph*)malloc(sizeof(AdjGraph));
    //给邻接表中所有头结点的指针域置空（初值）
    for (int i = 0; i < g.n; i++)
        G->adjlist[i].firstarc = NULL;
    
    //遍历邻接矩阵每个元素
    for (i = 0; i < g.n; i++){
        for (j = g.n - 1; j >= 0; j--){
            if (g.edges[i][j] != 0 && g.edges[i][j] < INF) {
                //创建一个结点p
                p = (ArcNode*)malloc(sizeof(ArcNode));;
                p->adjvex = j;
                p->weight = g.edges[i][j];
                //采用头插法插入p
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
    //置顶点数n和边数e
    G->n = g.n; G->e = g.e;
}

//将邻接表G转换成邻接矩阵g
void AdjToMat(MatGraph g, AdjGraph *G){
    int i,j;
    ArcNode *p;
    for(i = 0;i<G->n;i++){
        for(j = 0;j<G->n;j++){
            if(i==j){
                g.edges[i][i] = 0;
            }
            else g.edges[i][j] = INF;
        }
    }
    for(i = 0;i<G->n;i++){
        p = G->adjlist[i].firstarc;
        while(p!=NULL){
            g.edges[i][p->adjvex] = p->weight;
            p = p->nextarc;
        }
    }
    g.n = G->n;
    g.e = G->e;
}

//邻接矩阵的DFS算法，v-起点
void DFS_Mat(MatGraph g,int v) {
    int w;
    //访问v结点
    printf("%d ", v);
    visited[v] = 1;
    for (w = 0; w < g.n; w++) {
        //找顶点v的未访问过的相邻点w
        if (g.edges[v][w] != 0&& g.edges[v][w] != INF && visited[w] == 0)
            DFS_Mat(g, w);
    }
}

//邻接表的DFS算法，v-起点
void DFS_Adj(AdjGraph* G, int v) {
    int w;
    ArcNode* p;
    //访问v顶点
    printf("%d ", v);
    visited[v] = 1;
    //找v的第一个相邻结点
    p = G->adjlist[v].firstarc;
    //找v的所有相邻结点
    while (p != NULL) {
        //顶点v的相邻点w
        w = p->adjvex;
        //w未被访问
        if (visited[w] == 0){
            //从w出发进行深度优先遍历
            DFS_Adj(G, w);
        //找v的下一个相邻点
        }
        p = p->nextarc;
    }
}

//邻接矩阵的BFS算法，v-起点
void BFS_MAT(MatGraph g,int v) {
    int i, w, visited[MAXVEX];
    //定义一个循环队列QU
    int Qu[MAXVEX], front = 0, rear = 0;
    //visited[]置初值0；
    for (i = 0; i < g.n; i++){
        visited[i] = 0;
    }
    printf("%d ", v);
    visited[v] = 1;
    rear = (rear = 1) % MAXVEX;
    //初始顶点v进队
    Qu[rear] = v;
    //当对不为空：
    while (front != rear) {
        front = (front + 1) % MAXVEX;
        //出队顶点w
        w = Qu[front];
        //找与顶点w相邻的结点
        for (i = 0; i < g.n; i++){
            if (g.edges[w][i] != 0 && g.edges[w][i] != INF && visited[i] == 0) {
                //访问与w相邻的未被访问的结点
                printf("%d", i);
                //标记该顶点已被访问
                visited[i] = 1;
                rear = (rear + 1) % MAXVEX;
                //该结点进队
                Qu[rear] = i;
            }
        }
    }
}

//邻接表的BFS算法，v-起点
void BFS_Adj(AdjGraph* G, int v) {
    int i, w, visited[MAXVEX];
    int Qu[MAXVEX], front = 0, rear = 0;
    ArcNode* p;
    for (i = 0; i < G->n; i++)visited[i] = 0;
    printf("%d ", v);
    visited[v] = 1;
    rear = (rear = 1) % MAXVEX;
    Qu[rear] = v;
    while (front != rear) {
        front = (front + 1) % MAXVEX;
        w = Qu[front];
        p = G->adjlist[w].firstarc;
        while (p != NULL) {
            if (visited[p->adjvex] == 0) {
                printf("%d ", p->adjvex);
                visited[p->adjvex] = 1;
                rear = (rear + 1) % MAXVEX;
                Qu[rear] = p->adjvex;
            }
            p = p->nextarc;
        }
    }
}

//判断无向图G的连通性
int isConnect(AdjGraph *G){
    int i,flag = 1;
    DFS_Adj(G, 0);
    for(i = 0;i<G->n;i++){
        if(visited[i] == 0){
            flag = 0;
            /*
            printf("\n图G是非连通图\n");
             */
            break;
        }
    }
    /*
    if(flag){
        printf("\n图G是连通图\n");
    }*/
    return flag;
}

//判断无向图G中顶点u到顶点v之间是否有简单路径
int HasaPath(AdjGraph *G, int u,int v){
    ArcNode *p;
    int w;
    visited[u] = 1;
    //p指向u的第一个相邻点
    p = G->adjlist[u].firstarc;
    while(p!=NULL){
        //相邻点的编号为w
        w = p->adjvex;
        //找到顶点v后返回1；
        if(w == v){
            return 1;
        }
        //若顶点w没有访问过
        if(visited[w] == 0){
            //从哪个w出发进行深度优先遍历
            //若从w出发找到顶点v返回1
            if(HasaPath(G, w, v)){
                return 1;
            }
        }
        //p指向下一个相邻点
        p = p->nextarc;
    }
    //没有找到v，返回0；
    return 0;
}

//递归思路模型：
//大问题：f(G,u,v)--顶点u到v是否存在简单路径；小问题：f(G,w,v)--从顶点u找到一个未访问的相邻点w

//递归模型：
//f(G,u,v) = 1          当u = v
//f(G,u,v) = f(G,w,v)   对于顶点u的所有未访问的相邻点w（存在这样的w）
//f(G,u,v) = 0          其他情况
//该问题的递归实现如下：
int HasaPath_1(AdjGraph *G,int u,int v){
    ArcNode *p;
    int w;
    //找到顶点v后返回1；
    if(u == v){
        return 1;
    }
    visited[u] = 1;
    //p指向u的第一个相邻点
    p = G->adjlist[u].firstarc;
    while(p!=NULL){
        //相邻点编号为w
        w = p->adjvex;
        if(visited[w] == 0){
            //从w出发进行深度优先遍历
            if(HasaPath_1(G,w,v)){
                return 1;
            }
        }
        //p指向下一个相邻点
        p = p->nextarc;
    }
    //没有找到返回0；
    return 0;
}

//求无向图G中顶点u到顶点v的一条简单路径（假设存在一条或多条简单路径）
void FindaPath(AdjGraph *G,int u,int v,int path[],int d){
    ArcNode *p;
    int w,i;
    visited[u] = 1;
    d++;
    //定点u加入路径
    path[d] = u;
    
    //如果找出了一条路径：
    if(u == v){
        //输出一条路径并返回
        for(i = 0;i<=d;i++){
            printf("%d ",path[i]);
        }
        printf("\n");
        return ;
    }
    
    //还没找到：p指向u的第一个相邻点
    p = G->adjlist[u].firstarc;
    while(p != NULL){
        //相邻点的编号为w
        w = p->adjvex;
        if(visited[w] == 0){
            //递归调用
            FindaPath(G, w, v, path, d);
            //p指向下一个相邻点
            p = p->nextarc;
        }
    }
}

//求无向图G中顶点u到顶点v之间的全部简单路径
void FindAllPath(AdjGraph *G, int u,int v,int path[], int d){
    ArcNode *p;
    int w,i;
    visited[u] = 1;
    d++;
    //顶点u加入路径
    path[d] = u;
    
    //找到一条长度大于等于1的简单路径
    if(u == v && d>=1){
        //输出路径
        for(i = 0;i<=d;i++){
            printf("%d ",path[i]);
        }
        printf("\n");
    }
    
    //p指向u的第一个相邻点
    p = G->adjlist[u].firstarc;
    while(p!=NULL){
        //相邻点的编号为w
        w = p->adjvex;
        if(visited[w] == 0){
            //递归调用
            FindAllPath(G, w, v, path, d);
        }
        //p指向下一个相邻点
        p = p->nextarc;
    }
    //【回溯】找所有简单路径
    visited[u] = 0;
}
//说明：【带回溯的】DFS

//求不带权无向连通图G中从顶点u到顶点v的一条最短逆路径
void ShortPath(AdjGraph *G, int u,int v){
    //非循环队列类型
    //定义一个非循环队列qu
    struct QUEUE{
        //定点编号
        int data;
        //前一个顶点位置
        int parent;
    }qu[MAXVEX];
    
    //队列的头、尾指针
    int front = -1,rear = -1;
    ArcNode *p;
    int w,i;
    
    //访问标记置初值0
    for(i = 1;i<G->n;i++){
        visited[i] = 0;
    }
    //顶点u进队
    rear++;
    qu[rear].data = u;
    //顶点的双亲置为-1，标记u已访问
    qu[rear].parent = -1;
    visited[u] = 1;
    
    //队不空，循环
    while(front != rear){
        //出队顶点w；
        front++;
        w = qu[front].data;
        //找到v时输出路径之逆并退出；
        if(w == v){
            //通过队列输出逆路径
            i = front;
            while(qu[i].parent != -1){
                printf("%d ",qu[i].data);
                i = qu[i].parent;
            }
            printf("%d\n",qu[i].data);
            //找到路径后推出while循环
            break;
        }
        
        //找到w的第一个相邻点
        p = G->adjlist[w].firstarc;
        while(p != NULL){
            if(visited[p->adjvex] == 0){
                visited[p->adjvex] = 1;
                //将w的未被访问过的相邻点进队
                rear++;
                qu[rear].data = p->adjvex;
                //进队顶点的双亲置为front
                qu[rear].parent = front;
            }
            //找w的下一个相邻点
            p = p->nextarc;
        }
    }
}

//输出从顶点v出发的所有最短路径
void DispAllPath(MatGraph g,int dist[],int path[],int S[],int v){
    int i,j,k;
    //存放一条最短路径（逆向）及其顶点个数
    int apath[MAXVEX],d;
    //循环输出从顶点v到i的路径
    for(i = 0;i<g.n;i++){
        if(S[i] == 1 && i != v){
            printf(" 从%d到%d最短路径长度为：%d\t路径：",v,i,dist[i]);
            //添加路径上的终点
            d = 0;
            apath[d] = i;
            k = path[i];
            //没有路径的情况
            if(k == -1){
                printf("无路径\n");
            }
            else{
                while(k != v){
                    d++;
                    apath[d] = k;
                    k = path[k];
                }
                //添加路径上的起点
                d++;
                apath[d] = v;
                //先输出起点
                printf("%d",apath[d]);
                //再输出其他顶点
                for(j = d-1;j>=0;j--){
                    printf("→%d",apath[j]);
                }
                printf("\n");
            }
        }
    }
}

//Dijkstra求从v到其他顶点的最短路径
//时间复杂度O(n^2)
void Dijkstra(MatGraph g, int v){
    //保存从源点v到顶点i的目前最短路径
    int dist[MAXVEX];
    //保存从源点v到顶点i的最短路径
    int path[MAXVEX];
    //顶点集S
    int S[MAXVEX];
    
    int mindis,i,j,u = 0;
    for(i = 0;i<g.n;i++){
        //距离初始化
        dist[i] = g.edges[v][i];
        //S置空
        S[i] = 0;
        
        //路径初始化
        //顶点v到顶点i有边时，置顶点i的前一个顶点为v
        if(g.edges[v][i]<INF){
            path[i] = v;
        }
        //没有边，则置-1
        else{
            path[i] = -1;
        }
    }
    
    //源点编号v放入S中
    S[v] = 1;
    //循环向S中添加n-1个顶点
    for(i = 0;i<g.n-1;i++){
        mindis置最小长度初值
        mindis = INF;
        //选取不在S中且具有最小距离的顶点画
        for(j = 0;j<g.n;j++){
            if(S[j] == 0 && dist[j] < mindis){
                u = j;
                mindis = dist[j];
            }
        }
        
        //顶点u加入S中
        printf("将顶点%d加入S中\n",u);
        S[u] = 1;
        
        //修改不在S中的顶点的距离
        for(j = 0;j<g.n;j++){
            if(S[j] == 0){
                //如果新距离更小
                if(g.edges[u][i]<INF && dist[u] + g.edges[u][i]<dist[j]){
                    //更新距离
                    dist[j] = dist[u] + g.edges[u][i];
                    //更新前一顶点编号
                    path[j] = u;
                }
            }
        }
    }
    //输出所有最短路径及长度
    DispAllPath(g,dist,path,S,v);
}

void Prim(MatGraph g,int v) {
    int lowcost[MAXVEX];
    int closet[MAXVEX];
    int min, i, j, k;
    //给lowcost[]和closest[]置初值;
    for (i = 0; i < g.n; i++) {
        lowcost[i] = g.edges[v][i];
        closet[i] = v;
    }

    //构造n-1条边
    for (i = 1; i < g.n; i++) {
        min = INF; k = -1;
        //在V\U中找出离U最近的顶点k
        for(j = 0;j<g.n;j++)
            //更新、找到最近顶点的编号
            if (lowcost[j] != 0 && lowcost[j] < min) {
                min = lowcost[j];
                k = j;
            }
        //printf(" 边（%d,%d),权值为%d,\n", closet[k], k, min);
        printf("%d ",min);
        //标记k已加入U集合
        lowcost[k] = 0;
        //修正数组lowcost和closest
        for (j = 0; j < g.n; j++) {
            if (lowcost[j] != 0 && g.edges[k][j] < lowcost[j]) {
                lowcost[j] = g.edges[k][j];
                closet[j] = k;
            }
        }
    }
}



//多源最短路径算法
//佛洛依德(Floyd)算法

struct ParkLoc{
    int sign;
    string Loc;
};

int main() {
    int LocNum;
    cin>>LocNum;
    
    ParkLoc *Park = new ParkLoc[LocNum];
    string Loc;
    for(int i = 0;i<LocNum;i++){
        cin>>Loc;
        Park[i].Loc = Loc;
        Park[i].sign = i;
    }
    
    int A[MAXVEX][MAXVEX];
    for(int i = 0;i<LocNum;i++){
        for(int j = 0;j<LocNum;j++){
            A[i][j] = INF;
        }
    }
    
    int RoadNum;
    cin>>RoadNum;
    string Loc1,Loc2;
    int sign1,sign2;
    int dist;
    for(int i = 0;i<RoadNum;i++){
        cin>>Loc1>>Loc2;
        sign1 = sign2 = -1;
        for(int j = 0;j<LocNum;j++){
            if(sign1 != -1 && Park[j].Loc == Loc1){
                sign1 = j;
            }
            if(sign2 != -1 && Park[j].Loc == Loc2){
                sign2 = j;
            }
            if(sign1 != -1 && sign2 != -1) break;
        }
        cin>>dist;
        A[sign1][sign2] = A[sign2][sign1] = dist;
    }
    
    MatGraph g;
    
    CreateMatGraph(g, A, 7, 12);
    Dijkstra(g, 1);
    //    MatToAdj(g, G);
    //    DispAdjGraph(G);
    //int begin;
    //scanf("%d", &begin);
    //BFS_Adj(G, begin);
}

/*
 AdjGraph* G;
 for (int i = 0; i < length; i++) {
     visited[i] = 0;
 }

 //MatGraph g;
 int A[7][MAXVEX] = {
     {0,2,5,3,INF,INF,INF},
     {INF,0,2,INF,INF,8,INF},
     {INF,INF,0,1,3,5,INF},
     {INF,INF,INF,0,5,INF,INF},
     {INF,INF,INF,INF,0,3,9},
     {INF,INF,INF,INF,INF,0,5},
     {INF,INF,INF,INF,INF,INF,0}
 };
 CreateAdjGraph(G, A, 7, 12);
 //    MatToAdj(g, G);
 //    DispAdjGraph(G);
 int begin;
 scanf("%d", &begin);
 BFS_Adj(G, begin);
 */

/*
    AdjGraph* G;
    MatGraph g;
    
    CreateMatGraph(<#MatGraph &g#>, <#int (*A)[100]#>, <#int n#>, <#int e#>);
    DestroyMatGraph(<#MatGraph g#>);
    DispMatGraph(<#MatGraph g#>);
    Degree_Mat1(<#MatGraph g#>, <#int v#>);
    Degree_Mat2(<#MatGraph g#>, <#int v#>);
    CreateAdjGraph(<#AdjGraph *&G#>, <#int (*A)[100]#>, <#int n#>, <#int e#>);
    DestroyAdjGraph(<#AdjGraph *&G#>);
    DispAdjGraph(<#AdjGraph *G#>);
    Degree_Adj1(<#AdjGraph *G#>, <#int v#>);
    Degree_Adj2(<#AdjGraph *G#>, <#int v#>);
    MatToAdj(<#MatGraph g#>, <#AdjGraph *&G#>);
    AdjToMat(<#MatGraph g#>, <#AdjGraph *G#>);
    DFS_Mat(<#MatGraph g#>, <#int v#>);
    DFS_Adj(<#AdjGraph *G#>, <#int v#>);
    BFS_MAT(<#MatGraph g#>, <#int v#>);
    BFS_Adj(<#AdjGraph *G#>, <#int v#>);
    isConnect(<#AdjGraph *G#>);
    HasaPath(<#AdjGraph *G#>, <#int u#>, <#int v#>);
    HasaPath_1(<#AdjGraph *G#>, <#int u#>, <#int v#>);
    FindaPath(<#AdjGraph *G#>, <#int u#>, <#int v#>, <#int *path#>, <#int d#>);
    FindAllPath(<#AdjGraph *G#>, <#int u#>, <#int v#>, <#int *path#>, <#int d#>);
    ShortPath(<#AdjGraph *G#>, <#int u#>, <#int v#>);
    Dijkstra(<#MatGraph g#>, <#int v#>);
*/
就可以表示感谢啦
catlv77
关注
0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据结构C++语言版 -- 图

大二学生的 C++数据结构有部分Openjudge提交的代码没有删除邮箱：liu_772021@yeah.net欢迎交流讨论~有用的话，点赞留言```#include <iostream>#include <stdio.h>#include <cstring>#include <stdlib.h>#include <math.h>using namespace std;//图中最大顶点数#define M.
复制链接

扫一扫