图的基本算法——C/C++

图的结构体定义

typedef struct vertex {
    int number;					//顶点的编号
}VertexType; 					//别名，顶点的类型

typedef struct matrix {
    int n;						//顶点个数
    int e;						//边数
    int adjMat[MAXV][MAXV];		//邻接矩阵数组
    VertexType ver[MAXV];		//存放顶点信息
}MatGraph;						//别名，完整的图邻接矩阵类型

typedef struct eNode {
    int adjVer;					//该边的邻接点编号
    int weight;					//该边的的信息，如权值
    struct eNode* nextEdge;		//指向下一条边的指针
}EdgeNode; 						//别名，边结点的类型

typedef struct vNode {
    EdgeNode* firstEdge;		//指向第一个边结点
}VNode; 						//别名，邻接表的头结点类型

typedef struct list {
    int n;						//顶点个数
    int e;						//边数
    VNode adjList[MAXV];		//邻接表的头结点数组
}ListGraph;						//别名，完整的图邻接表类型

函数

//创建图的邻接表
void createAdjListGraph(ListGraph*& LG, int A[MAXV][MAXV], int n, int e)
根据邻接矩阵数组A、顶点个数n、边数e来建立图的邻接表 LG（采用邻接表指针方式）:
（1）为邻接表分配LG的存储空间，并将所有头结点的firstEdge指针置为空（NULL）。
（2）扫描数组A查找不为0的元素，若找到这样的元素A[i][j],创建一个adjVer域为 j、weight域为A[i][j]的边结点。
（3）采用头插法将他插入到第 i 个单链表中。

 //输出邻接表
void displayAdjList(ListGraph* LG)
（1）扫描邻接表LG的头结点数组adjList.
（2）对于每个单链表，先输出头结点的顶点信息（这里输出编号）.
（3）然后逐一输出单链表中的所有结点的信息。

//输出邻接矩阵
void displayAdjMat(MatGraph MG)
这个就和数组的输出一样，只是要判断临界条件
 
 //邻接表转换为邻接矩阵
void ListToMat(ListGraph* LG, MatGraph &MG)
（1）在图的邻接矩阵MG查找不为0、不为 ∞ 的元素。
（2）若找到这样的元素MG.adjMat[i][j],创建一个adjVer域为 j、weight域为MG.adjMat[i][j]的边结点。
（3）采用头插法将他插入到第 i 个单链表中。

 //销毁图
void destroyAdjListGraph(ListGraph* LG)

完整代码

#include <stdio.h>
#include <cstdlib>

#define MAXV 5					//最大顶点个数
#define INF 32767				//定义 ∞


typedef struct vertex {
    int number;					//顶点的编号
}VertexType; 					//别名，顶点的类型

typedef struct matrix {
    int n;						//顶点个数
    int e;						//边数
    int adjMat[MAXV][MAXV];		//邻接矩阵数组
    VertexType ver[MAXV];		//存放顶点信息
}MatGraph;						//别名，完整的图邻接矩阵类型

typedef struct eNode {
    int adjVer;					//该边的邻接点编号
    int weight;					//该边的的信息，如权值
    struct eNode* nextEdge;		//指向下一条边的指针
}EdgeNode; 						//别名，边结点的类型

typedef struct vNode {
    EdgeNode* firstEdge;		//指向第一个边结点
}VNode; 						//别名，邻接表的头结点类型

typedef struct list {
    int n;						//顶点个数
    int e;						//边数
    VNode adjList[MAXV];		//邻接表的头结点数组
}ListGraph;						//别名，完整的图邻接表类型

//根据邻接矩阵来创建图的邻接表
//其实就是利用图，将邻接矩阵转化为邻接表，void MatToList(MatGraph MG, ListGraph* &LG)
//参数A=MG.adjMat[i][j],n = MG.n,e = MG.e
void createAdjListGraph(ListGraph*& LG,int A[MAXV][MAXV],int n,int e){
    int i,j;
    EdgeNode *p;
    LG = (ListGraph*)malloc(sizeof(ListGraph));
    for(i=0;i<n;i++){
        LG->adjList[i].firstEdge = NULL;
    }
    for (i = 0; i < n; ++i) {
        for (j = n-1; j >= 0; ++j) {
            if (A[i][j]!=0){
                p = (EdgeNode*)malloc(sizeof(EdgeNode));
                p->adjVer = j;
                p->weight = A[i][j];
                p->nextEdge = LG->adjList[i].firstEdge;
                LG->adjList[i].firstEdge = p;
            }
        }
    }
    LG->n = n;
    LG->e = e;
}

//根据邻接表转化为邻接矩阵
void ListToMat(ListGraph* LG,MatGraph &MG){
    int i,j;
    EdgeNode *p;
    for ( i = 0; i < MAXV; ++i) {
        for ( j = 0; j < MAXV; ++j) {
            MG.adjMat[i][j] = 0;
        }
    }
    for ( i = 0; i < LG->n; ++i) {
        p = LG->adjList[i].firstEdge;
        while (p != NULL){
            MG.adjMat[i][p->adjVer] = p->weight;
            p = p->nextEdge;
        }
    }
    MG.n = LG->n;
    MG.e = LG->e;
}

//输出邻接表：扫描邻接表并输出
void displayAdjList(ListGraph*& LG){
    int i;
    EdgeNode *p;
    for (i = 0; i < MAXV; ++i) {
        p = LG->adjList[i].firstEdge;
        printf("%d:",i);
        while (p != NULL){
            if (p->weight!=INF){
                printf("%2d[%d]->",p->adjVer,p->weight);
            }
            p = p->nextEdge;
        }
        printf("NULL\n");
    }
}

//输出邻接矩阵：扫描图的邻接矩阵并输出
void displayAdjMat(MatGraph MG) {
    int i, j;
    for (i = 0; i < MAXV; i++) {
        for (j = 0; j < MAXV; j++) {
            if (MG.adjMat[i][j] == 0) {
                printf("%4s", "0");
            }
            else if (MG.adjMat[i][j] == INF) {
                printf("%4s", "∞");
            }
            else {
                printf("%4d", MG.adjMat[i][j]);
            }
        }
        printf("\n");
    }
}

//销毁图
void destroyAdjListGraph(ListGraph* LG) {
    int i;
    EdgeNode* pre, * p;
    for (i = 0; i < LG->n; i++) {
        pre = LG->adjList[i].firstEdge;				//挨个释放内存
        if (pre != NULL) {
            p = pre->nextEdge;
            while (p != NULL) {
                free(pre);
                pre = p;
                p = p->nextEdge;
            }
            free(pre);
        }
    }
    free(LG);
}

int main() {
    ListGraph* LG;						//邻接表
    MatGraph MG;						//邻接矩阵
    int array1[MAXV][MAXV] = {			//不带权无向图
            {0,1,0,1,1},
            {1,0,1,1,0},
            {0,1,0,1,1},
            {1,1,1,0,1},
            {1,0,1,1,0}
    };
    int array2[MAXV][MAXV] = {			//不带权有向图
            {0,1,0,1,0},
            {0,0,1,1,0},
            {0,0,0,1,1},
            {0,0,0,0,0},
            {1,0,0,1,0}
    };
    int array3[MAXV][MAXV] = {			//带权无向图
            {  0,  8,INF,  5,INF},
            {  8,  0,  3,INF,INF},
            {INF,  3,  0,  9,  6},
            {  5,INF,  9,  0,INF},
            {INF,INF,  6,INF,  0}
    };
    int array4[MAXV][MAXV] = {			//带权有向图
            {  0,  8,INF,  5,INF},
            {INF,  0,  3,INF,INF},
            {INF,INF,  0,INF,  6},
            {INF,INF,  9,  0,INF},
            {INF,INF,INF,INF,  0}
    };
    int e = 5;
    createAdjListGraph(LG, array1, MAXV, e);		//创建邻接表图
    displayAdjList(LG);								//输出邻接表
    printf("\n");

    ListToMat(LG, MG);								//邻接表转换为邻接矩阵
    displayAdjMat(MG);								//输出邻接矩阵
    printf("\n");

    return 0;
}

详细讲解请转到：https://blog.csdn.net/weixin_42109012/article/details/94140343