数据结构（5）—— 图

写在前面

图这一节，考察最多的依然是算法的实现过程，而不是代码本身。但实现还是要实现的。

本文代码的实现参考了数据结构与算法系列 目录 - 如果天空不死 - 博客园 (cnblogs.com)的博客与王道书上的逻辑。

按照惯例，上一节：数据结构（4）—— 树与二叉树

图的存储结构以及遍历

注意点

这块内容比较少，就都写在一块了。图的类型主要是有向图与无向图，图的存储主要是邻接表与邻接矩阵，遍历主要是深度优先遍历与广度优先遍历。这里的实现没有太多要注意的点，主要就是按照王道书和我大二初学时的代码加以改造而成的。主要实现了无向图的邻接矩阵的广度优先与深度优先遍历，由于邻接表的遍历实现类似，就没有重复写了。

代码

无向图

/*
 * @Description: 无向图的相关算法实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-21 20:53:36
 */
#include<bits/stdc++.h>
// 顶点类型,由用户自己定义
typedef char VertexType; 
// 边上的权值类型,由用户自己定义
typedef int  EdgeType;  
// 最大顶点数,由用户定义
#define MAX_VEX 20  
// 用int的最大值来代表无穷大
#define	INFINITY 65535
// 访问数组，用来标识结点是否被访问过
int visited[MAX_VEX]={0};

// 用邻接矩阵法表示无向图
typedef struct{
    // 顶点数组
	VertexType vexs[MAX_VEX]; 
    // 邻接矩阵
	EdgeType arc[MAX_VEX][MAX_VEX];
    // 图中当前定点数和边数
	int vexNum, arcNum; 
}Graph;

// *******************队列相关定义开始*******************
// 定义结点的结构
typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;
// 定义链式队列的结构
typedef struct{
    LinkNode *front;
    LinkNode *rear;
}LinkQueue;

// 初始化
void initQueue(LinkQueue &Q){
    // 建立头结点
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

// 判队空
bool isEmpty(LinkQueue Q){
    return Q.front == Q.rear;
}

// 入队
void enQueue(LinkQueue &Q,int x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;
    // 队尾指针移动到新的尾部
    Q.rear = s;
}

// 出队
bool deQueue(LinkQueue &Q,int &x){
    if(isEmpty(Q)){
        return false;
    }
    LinkNode *p = Q.front->next;
    x = p->data;
    Q.front->next = p->next;
    // 如果原队列只有一个结点，删除后变空
    if(Q.rear == p){
        Q.rear = Q.front;
    }
    free(p);
    return true;
}
// *******************队列相关定义结束*******************

// 定位顶点v在顶点数组的下标位置,不存在返回-1
int locateVex(Graph g, VertexType v)
{
	int i = 0;
	for (i = 0; i < g.vexNum; i++)
	{
		if (g.vexs[i]==v)
			break;
	}
	if (i > g.vexNum)
	{
		printf("结点不存在！");
		return -1;
	}
	return i;
}

// 用邻接矩阵表示法，构造无向网(图)g
void createUDN(Graph &g)
{
	int i, j;
	EdgeType w;
 
	printf("输入顶点数和边数:
");
	scanf("%d,%d", &(g.vexNum), &(g.arcNum));
	// 输入顶点
	for(i = 0; i < g.vexNum; i++)
	{
		printf("顶点%d:", i + 1);
		g.vexs[i]=getchar();
		while(g.vexs[i]=='
'){
			g.vexs[i]=getchar();
		}
	}
	getchar();
	//初始化邻接矩阵
	for (i = 0; i < g.arcNum; i++)
	{
		for (j = 0; j < g.arcNum; j++)
		{
			g.arc[i][j] = INFINITY;  
		}
	}
 
	printf("输入边(vi, vj)上的顶点vi vj和权值w
");
	for (i = 0; i < g.arcNum; i++)
	{		
		char v1, v2;
		scanf("%c %c %d", &v1, &v2, &w);
		getchar();
		int m = locateVex(g, v1);
		int n = locateVex(g, v2);
		if (m == -1 || n == -1)
		{
			printf("结点不存在！");
			return;
		}
		g.arc[m][n] = w;
		#if 1
        // 按照对称直接赋值
		g.arc[n][m] = g.arc[m][n];
		#endif	
	}
}

// 打印图
void printGraph(Graph g)
{
	int i=0,j=0; 
	printf("领接矩阵表为:
");
	for (i = 0; i < g.vexNum; i++)
	{
		for (j = 0; j < g.vexNum; j++)
		{
			printf("%6d", g.arc[i][j]);
		}
		putchar('
');
	}
}

// 图的深度优先遍历算法 
void DFS_AM(Graph G,int v){
	printf("%c ",G.vexs[v]);
	visited[v] = 1;
	int w;
	for(w = 0;w < G.vexNum;w++){
		if((G.arc[v][w] != INFINITY)&&(!visited[w])){
			DFS_AM(G,w);
		}
	}
}
// 广度优先遍历算法
void BFSTraverse(Graph g)
{
	LinkQueue q;
	int v;
	for (v = 0; v < g.vexNum; v++)
		visited[v] = 0;
	initQueue(q);
	for (v = 0; v < g.vexNum; v++)
    	// 第v个顶点尚未访问
		if (!visited[v])
		{
			visited[v] = 1;
            // 打印顶点，也可以是其他操作
			printf("%c ", g.vexs[v]);
            // 第v个顶点入队列
			enQueue(q, v);
			while (!isEmpty(q))
			{
				int i,j=0;
				deQueue(q, i);
				for (j = 0; j < g.vexNum; j++)	  
					// 判断其他顶点若与当前顶点存在边且未访问过
					if (g.arc[i][j] > 0 && g.arc[i][j] != INFINITY && !visited[j])
					{
                        // j为i尚未访问过的邻接顶点
						visited[j] = 1;		 
						printf("%c ", g.vexs[j]);	 
						enQueue(q, j);	
					}
			}
		}
}

// 主函数测试
int main(){
    Graph G;
    createUDN(G);
    printGraph(G);
    printf("深度优先遍历结果为：
");
    DFS_AM(G,0);
    printf("
");
    printf("广度优先遍历结果为：
");
    BFSTraverse(G);
    return 0;
}

有向图

/*
 * @Description: 有向图的相关算法实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-21 21:15:19
 */

#include<bits/stdc++.h>
// 顶点类型,由用户自己定义
typedef char VertexType;
// 边上的权值类型,由用户自己定义
typedef int  EdgeType;
// 最大顶点数,由用户定义
#define MAX_VEX 20

// 使用邻接表法表示有向图
// 边表结点
typedef struct EdgeNode	
{
    // 邻接点域，存储该顶点在顶点表中的下标
	int adjvex;	
    // 网图权值
	EdgeType weight;
   	// 链域，指向下一个邻接点 
	struct EdgeNode *next;
}EdgeNode;
// 顶点表结点
typedef struct VertexNode
{
    // 顶点域，存储顶点信息
	VertexType data;
    // 边表头指针
	EdgeNode *firstedge;
}VertexNode, AdjList[MAX_VEX];
typedef struct  
{
	AdjList adjList;
    // 图中当前顶点数和弧数 
	int vexNum, arcNum; 
}GraphList;

// 定位顶点v在顶表的下标位置,不存在返回-1
int locateVex(GraphList g, VertexType v)
{
	int i;
	for (i = 0; i < g.vexNum; i++)
	{
		if (v == g.adjList[i].data )
			break;
	}
	if (i > g.vexNum)
	{
		printf("结点不存在！");
		return -1;
	}
	return i;
}

// 用邻接表表示法，构造有向网g
void createGraph(GraphList &g)
{
	int i, j;
	EdgeType w;
	EdgeNode *e, *f;
	printf("输入顶点数和边数:
");
	scanf("%d,%d", &(g.vexNum), &(g.arcNum)); 
	//输入顶点
	for (i = 0; i < g.vexNum; i++)
	{
		printf("顶点%d:", i+1);
		g.adjList[i].data = getchar();
		g.adjList[i].firstedge = NULL;
		while(g.adjList[i].data == '
')
		{
			g.adjList[i].data = getchar();
		}
	}
	getchar();
	// 建立边表
	printf("输入边(vi, vj)上的顶点vi vj和权值w
");
	for (i = 0; i < g.arcNum; i++)
	{		
		char v1, v2;
		scanf("%c %c %d", &v1, &v2, &w);
		getchar();
		int m = locateVex(g, v1);
		int n = locateVex(g, v2);
		if (m == -1 || n == -1)
		{
			printf("结点不存在！");
			return;
		}
		//向内存申请空间，生成边表结点
		e = (EdgeNode*)malloc(sizeof(EdgeNode));
		if(e == NULL)
		{
			printf("内存空间申请失败！");
			return;
		}
        // 邻接序号为n
		e->adjvex = n;
        // 权值
		e->weight = w;
        // 单链表的头插法
		e->next = g.adjList[m].firstedge;
		g.adjList[m].firstedge = e;
	}
}

void printGrapth(GraphList g)
{
	int i;
    printf("邻接表为：
");
	for (i = 0; i < g.vexNum; i++)
	{
		printf("顶点%c ", g.adjList[i].data) ;
		EdgeNode *e = g.adjList[i].firstedge;
		while (e != NULL)
		{
			printf("―> <%c, %c> 权值为: %d  ", g.adjList[i].data, g.adjList[e->adjvex].data, e->weight);
			e = e->next;
		}
		putchar('
');
	}
}

// 主函数测试
int main(){
    GraphList G;
    createGraph(G);
    printGrapth(G);
    return 0;
}

最小生成树——Prim算法

注意点

书上在这块有两种算法，Prim和Kruskal算法。我这里随便挑选了一种来实现，另一种的实现就不再写了。Prim算法实现的重点是要遍历找到权值最小的边，然后加入到顶点集合中。具体实现看代码好了。

代码

/*
 * @Description: Prim算法的实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-24 19:41:35
 */
#include<bits/stdc++.h>

// 顶点类型,由用户自己定义
typedef char VertexType; 
// 边上的权值类型,由用户自己定义
typedef int  EdgeType;  
// 最大顶点数,由用户定义
#define MAX_VEX 20  
// 用int的最大值来代表无穷大
#define	INFINITY 65535
// 访问数组，用来标识结点是否被访问过
int visited[MAX_VEX]={0};

// 用邻接矩阵法表示无向图
typedef struct{
    // 顶点数组
	VertexType vexs[MAX_VEX]; 
    // 邻接矩阵
	EdgeType arc[MAX_VEX][MAX_VEX];
    // 图中当前定点数和边数
	int vexNum, arcNum; 
}Graph;

// 定位顶点v在顶点数组的下标位置,不存在返回-1
int locateVex(Graph g, VertexType v)
{
	int i = 0;
	for (i = 0; i < g.vexNum; i++)
	{
		if (g.vexs[i]==v)
			break;
	}
	if (i > g.vexNum)
	{
		printf("结点不存在！");
		return -1;
	}
	return i;
}

// 用邻接矩阵表示法，构造无向网(图)g
void createUDN(Graph &g)
{
	int i, j;
	EdgeType w;
 
	printf("输入顶点数和边数:
");
	scanf("%d,%d", &(g.vexNum), &(g.arcNum));
	// 输入顶点
	for(i = 0; i < g.vexNum; i++)
	{
		printf("顶点%d:", i + 1);
		g.vexs[i]=getchar();
		while(g.vexs[i]=='
'){
			g.vexs[i]=getchar();
		}
	}
	getchar();
	//初始化邻接矩阵
	for (i = 0; i < g.arcNum; i++)
	{
		for (j = 0; j < g.arcNum; j++)
		{
			g.arc[i][j] = INFINITY;  
		}
	}
 
	printf("输入边(vi, vj)上的顶点vi vj和权值w
");
	for (i = 0; i < g.arcNum; i++)
	{		
		char v1, v2;
		scanf("%c %c %d", &v1, &v2, &w);
		getchar();
		int m = locateVex(g, v1);
		int n = locateVex(g, v2);
		if (m == -1 || n == -1)
		{
			printf("结点不存在！");
			return;
		}
		g.arc[m][n] = w;
		#if 1
        // 按照对称直接赋值
		g.arc[n][m] = g.arc[m][n];
		#endif	
	}
}

// prim 算法生成最小生成树
void prim(Graph G, int start)
{
    int min,i,j,k,m,n,sum;
    // 最小生成树的索引，即prims数组的索引
    int index=0;         
    // 存储最小生成树的数组
    char prims[MAX_VEX];  
    // 顶点间边的权值  
    int weights[MAX_VEX]; 

    // prim最小生成树中第一个数是"图中第start个顶点"，因为是从start开始的。
    prims[index++] = G.vexs[start];

    // 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
    for (i = 0; i < G.vexNum; i++){
        weights[i] = G.arc[start][i];
    }
    // 将第start个顶点的权值初始化为0。
    weights[start] = 0;
    for (i = 0; i < G.vexNum; i++)
    {
        // 由于从start开始的，因此不需要再对第start个顶点进行处理。
        if(start == i){
            continue;
        }
        j = 0;
        k = 0;
        min = INFINITY;
        // 在未被加入到最小生成树的顶点中，找出权值最小的顶点。
        while (j < G.vexNum)
        {
            // 若weights[j]=0，意味着"第j个节点已经被加入到了最小生成树中"
            if (weights[j] != 0 && weights[j] < min)
            {
                min = weights[j];
                k = j;
            }
            j++;
        }

        // 经过上面的处理后，在未被加入到最小生成树的顶点中，权值最小的顶点是第k个顶点。
        // 将第k个顶点加入到最小生成树的结果数组中
        prims[index++] = G.vexs[k];
        // 将"第k个顶点的权值"标记为0 代表第k个顶点已经加入到了结果中
        weights[k] = 0;
        // 当第k个顶点被加入到最小生成树的结果数组中之后，更新其它顶点的权值。
        for (j = 0 ; j < G.vexNum; j++)
        {
            // 当第j个节点没有被处理，并且需要更新时才被更新。
            if (weights[j] != 0 && G.arc[k][j] < weights[j]){
                weights[j] = G.arc[k][j];
            }    
        }
    }

    // 计算最小生成树的权值
    sum = 0;
    for (i = 1; i < index; i++)
    {
        min = INFINITY;
        // 获取prims[i]在G中的位置
        n = locateVex(G, prims[i]);
        // 在vexs[0...i]中，找出到j的权值最小的顶点。
        for (j = 0; j < i; j++)
        {
            m = locateVex(G, prims[j]);
            if (G.arc[m][n]<min){
                min = G.arc[m][n];
            }
        }
        sum += min;
    }
    // 打印最小生成树
    printf("PRIM(%c)=%d: ", G.vexs[start], sum);
    for (i = 0; i < index; i++)
        printf("%c ", prims[i]);
    printf("
");
}

// 主函数测试
int main(){
    Graph G;
    createUDN(G);
    prim(G,0);
}

最短路径——Floyd算法

注意点

这里书上也是提出了两种算法，我选择了Floyd算法来进行实现，因为这种算法虽然时间复杂度更高但实现其实较为简单。在这里的实现中，重点就是如何更新A矩阵。直接看代码吧。其实就是一个三层循环，然后里面有

代码

/*
 * @Description: Floyd算法的实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-24 21:05:30
 */

#include <bits/stdc++.h>

#define MAXV 100
#define INF 9999
typedef struct
{
    int edges[MAXV][MAXV];
    int n, e;
} MGraph;
void ppath(int path[][MAXV], int i, int j)
{
    int k;
    k = path[i][j];
    if (k == -1)
        return;
    ppath(path, i, k);
    printf("%d,", k);
    ppath(path, k, j);
}
// 输出最短路径
void DisPath(int A[][MAXV], int path[][MAXV], int n)
{
    int i, j;
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            if (A[i][j] != INF && i != j){
                printf("  从%d到%d路径为:", i, j);
                printf("%d,", i);
                ppath(path, i, j);
                printf("%d", j);
                printf("	路径长度为:%d
", A[i][j]);
            }
        }
    }
}

// Floyd算法的实现
void Floyd(MGraph g)
{
    int A[MAXV][MAXV], path[MAXV][MAXV];
    int i, j, k, n = g.n;
    // 给A数组置初值
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            A[i][j] = g.edges[i][j];
            path[i][j] = -1;
        }
    }
    // 计算Ak
    for (k = 0; k < n; k++){
        for (i = 0; i < n; i++){
            for (j = 0; j < n; j++){
                if (A[i][j] > (A[i][k] + A[k][j])){
                    A[i][j] = A[i][k] + A[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
    printf("
输出最短路径:
");
    // 输出最短路径
    DisPath(A, path, n); 
}
//输出邻接矩阵g
void DispMat(MGraph 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("%3s", "∞");
            }else{
                printf("%3d", g.edges[i][j]);
            }
        }
        printf("
");
    }
}
int main(){
    int i, j, n;
    MGraph g;
    printf("请输入图中节点的个数
");
    scanf("%d", &n);
    int B[n][n];
    g.n = n;
    g.e = n;
    printf("请输入邻接矩阵
");
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            scanf("%d", &B[i][j]);
        }
    }
    for (i = 0; i < g.n; i++){
        for (j = 0; j < g.n; j++){
            g.edges[i][j] = B[i][j];
        }
    }
    //DispMat(g);
    Floyd(g);
    printf("
");
    return 0;
}

拓扑排序

注意点

这里是按照王道教材上的实现方法，对其进行了一部分改写，使用了栈进行实现。大概的思路很简单，每次都删掉入度为0的结点，然后输出结点，最后删完为止。具体实现看代码吧。

代码

/*
 * @Description: 拓扑排序的邻接表实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-24 20:14:44
 */
#include<bits/stdc++.h>

// 顶点类型,由用户自己定义
typedef char VertexType;
// 边上的权值类型,由用户自己定义
typedef int  EdgeType;
// 最大顶点数,由用户定义
#define MAX_VEX 20

#define maxSize 50
// 使用邻接表法表示有向图
// 边表结点
typedef struct EdgeNode	
{
    // 邻接点域，存储该顶点在顶点表中的下标
	int adjvex;	
    // 网图权值
	EdgeType weight;
   	// 链域，指向下一个邻接点 
	struct EdgeNode *next;
}EdgeNode;
// 顶点表结点
typedef struct VertexNode
{
    // 顶点域，存储顶点信息
	VertexType data;
    // 边表头指针
	EdgeNode *firstedge;
}VertexNode, AdjList[MAX_VEX];
typedef struct  
{
	AdjList adjList;
    // 图中当前顶点数和弧数 
	int vexNum, arcNum; 
}GraphList;

// ************顺序栈的相关实现************

// 顺序栈的存储结构
typedef struct{
    int data[maxSize];
    // 栈顶指针
    int top;
}SqStack;

// 初始化栈
void initStack(SqStack &S){
    // 这里把栈顶指针设为-1，也可以设为0
    S.top = -1;
}

// 判空
bool isStackEmpty(SqStack S){
    return S.top == -1;
}

// 进栈
bool push(SqStack &S, int e){
    // 栈满
    if(S.top == maxSize -1){
        return false;
    }
    S.data[++S.top] = e;
    return false;
}

// 出栈
bool pop(SqStack &S,int &e){
    // 栈空
    if(S.top == -1){
        return false;
    }
    e = S.data[S.top--];
    return true;
}

// 读栈顶元素
bool getTop(SqStack &S,int &e){
    if(S.top == -1){
        return false;
    }
    e = S.data[S.top];
    return true;
}
// ************顺序栈的相关实现结束************



// 定位顶点v在顶表的下标位置,不存在返回-1
int locateVex(GraphList g, VertexType v)
{
	int i;
	for (i = 0; i < g.vexNum; i++)
	{
		if (v == g.adjList[i].data )
			break;
	}
	if (i > g.vexNum)
	{
		printf("结点不存在！");
		return -1;
	}
	return i;
}

// 用邻接表表示法，构造有向网g
void createGraph(GraphList &g)
{
	int i, j;
	EdgeType w;
	EdgeNode *e, *f;
	printf("输入顶点数和边数:
");
	scanf("%d,%d", &(g.vexNum), &(g.arcNum)); 
	//输入顶点
	for (i = 0; i < g.vexNum; i++)
	{
		printf("顶点%d:", i+1);
		g.adjList[i].data = getchar();
		g.adjList[i].firstedge = NULL;
		while(g.adjList[i].data == '
')
		{
			g.adjList[i].data = getchar();
		}
	}
	getchar();
	// 建立边表
	printf("输入边(vi, vj)上的顶点vi vj和权值w
");
	for (i = 0; i < g.arcNum; i++)
	{		
		char v1, v2;
		scanf("%c %c %d", &v1, &v2, &w);
		getchar();
		int m = locateVex(g, v1);
		int n = locateVex(g, v2);
		if (m == -1 || n == -1)
		{
			printf("结点不存在！");
			return;
		}
		//向内存申请空间，生成边表结点
		e = (EdgeNode*)malloc(sizeof(EdgeNode));
		if(e == NULL)
		{
			printf("内存空间申请失败！");
			return;
		}
        // 邻接序号为n
		e->adjvex = n;
        // 权值
		e->weight = w;
        // 单链表的头插法
		e->next = g.adjList[m].firstedge;
		g.adjList[m].firstedge = e;
	}
}
// 拓扑排序
bool toplogicalSort(GraphList G){
    SqStack S;
    // 初始化一个栈，存储入度为0的结点
    initStack(S);
    // 统计每个顶点的入度数
    int indegree[100];
    EdgeNode *node;
    for(int i = 0; i < G.vexNum; i++)
    {
        node = G.adjList[i].firstedge;
        while (node != NULL)
        {
            indegree[node->adjvex]++;
            node = node->next;
        }
    }
    // 把所有度为0的结点存储到栈内
    for(int i = 0;i < G.vexNum;i++){
        if(indegree[i] == 0){
            push(S,i);
        }
    }
    // 开始进行拓扑排序
    int i;
    // 使用count记录输出了几个结点
    int count = 0;
    while(!isStackEmpty(S)){
        // 栈顶元素出栈
        pop(S,i);
        // 输出顶点i
        printf("%c ",G.adjList[i].data);
        count++;
        for(EdgeNode *p = G.adjList[i].firstedge;p != NULL;p = p->next){
            // 将所有i指向的顶点的入度减1，并且把入度为0的顶点压入栈S
            int v = p->adjvex;
            if(!(--indegree[v])){
                push(S,v);
            }
        }
    }
    return !(count < G.vexNum);
}

// 主函数测试
int main(){
    GraphList G;
    createGraph(G);
    printf("拓扑排序序列为：
");
    toplogicalSort(G);
    return 0;
}

总结

这一章的核心部分在图的应用，也就是后面几个算法的实现。关键路径我并没有实现，个人认为掌握手写做法就大概足够了。感谢网上的大佬资料。