数据结构–图(Graph)详解(三)

文章目录

数据结构--图(Graph)详解(三)
- 一、深度优先生成树和广度优先生成树
- - 1.铺垫
  - 2.非连通图的生成森林
  - 3.深度优先生成森林
  - 4.广度优先生成森林
- 二、几个特别NB的算法详解
- - 1.普里姆算法(Prim算法)求最小生成树
  - 2.克鲁斯卡尔算法(Kruskal算法)求最小生成树
  - 3.拓扑排序算法
  - 4.迪杰斯特拉(Dijkstra算法)算法
  - 5.弗洛伊德算法

一、深度优先生成树和广度优先生成树

1.铺垫

本博客来解决对于给定的无向图，如何构建它们相对应的生成树或者生成森林。

其实在对无向图进行遍历的时候，遍历过程中所经历过的图中的顶点和边的组合，就是图的生成树或者生成森林。

例如，图 1 中的无向图是由 V1～V7 的顶点和编号分别为 a～i 的边组成。

当使用深度优先搜索算法时，假设 V1 作为遍历的起始点，涉及到的顶点和边的遍历顺序为（不唯一）：

此种遍历顺序构建的生成树为：

由深度优先搜索得到的树为深度优先生成树。
同理，广度优先搜索生成的树为广度优先生成树

图 1 无向图以顶点 V1 为起始点进行广度优先搜索遍历得到的树，如图 3 所示：

2.非连通图的生成森林

非连通图在进行遍历时，实则是对非连通图中每个连通分量分别进行遍历，在遍历过程经过的每个顶点和边，就构成了每个连通分量的生成树。
非连通图中，多个连通分量构成的多个生成树为非连通图的生成森林。

3.深度优先生成森林

例如，对图 4 中的非连通图（a）采用深度优先搜索算法遍历时，得到的深度优先生成森林（由 3 个深度优先生成树构成）如（b）所示（不唯一）。

非连通图在遍历生成森林时，可以采用孩子兄弟表示法将森林转化为一整棵二叉树进行存储。

具体实现的代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERtEX_NUM 20                   //顶点的最大个数
#define VRType int                          //表示顶点之间的关系的变量类型
#define VertexType int                     //图中顶点的数据类型
typedef enum{false,true}bool;               //定义bool型常量
bool visited[MAX_VERtEX_NUM];               //设置全局数组，记录标记顶点是否被访问过typedef struct {VRType adj;                             //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值。
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];typedef struct {VertexType vexs[MAX_VERtEX_NUM];        //存储图中顶点数据AdjMatrix arcs;                         //二维数组，记录顶点之间的关系int vexnum,arcnum;                      //记录图的顶点数和弧（边）数
}MGraph;//孩子兄弟表示法的链表结点结构
typedef struct CSNode{VertexType data;struct CSNode * lchild;//孩子结点struct CSNode * nextsibling;//兄弟结点
}*CSTree,CSNode;//根据顶点本身数据，判断出顶点在二维数组中的位置
int LocateVex(MGraph G,VertexType v){int i=0;//遍历一维数组，找到变量vfor (; i<G.vexnum; i++) {if (G.vexs[i]==v) {break;}}//如果找不到，输出提示语句，返回-1if (i>G.vexnum) {printf("no such vertex.\n");return -1;}return i;
}//构造无向图
void CreateDN(MGraph *G){scanf("%d,%d",&(G->vexnum),&(G->arcnum));getchar();for (int i=0; i<G->vexnum; i++) {scanf("%d",&(G->vexs[i]));}for (int i=0; i<G->vexnum; i++) {for (int j=0; j<G->vexnum; j++) {G->arcs[i][j].adj=0;}}for (int i=0; i<G->arcnum; i++) {int v1,v2;scanf("%d,%d",&v1,&v2);int n=LocateVex(*G, v1);int m=LocateVex(*G, v2);if (m==-1 ||n==-1) {printf("no this vertex\n");return;}G->arcs[n][m].adj=1;G->arcs[m][n].adj=1;//无向图的二阶矩阵沿主对角线对称}
}int FirstAdjVex(MGraph G,int v)
{//查找与数组下标为v的顶点之间有边的顶点，返回它在数组中的下标for(int i = 0; i<G.vexnum; i++){if( G.arcs[v][i].adj ){return i;}}return -1;
}int NextAdjVex(MGraph G,int v,int w)
{//从前一个访问位置w的下一个位置开始，查找之间有边的顶点for(int i = w+1; i<G.vexnum; i++){if(G.arcs[v][i].adj){return i;}}return -1;
}void DFSTree(MGraph G,int v,CSTree*T){//将正在访问的该顶点的标志位设为truevisited[v]=true;bool first=true;CSTree q=NULL;//依次遍历该顶点的所有邻接点for (int w=FirstAdjVex(G, v); w>=0; w=NextAdjVex(G, v, w)) {//如果该临界点标志位为false，说明还未访问if (!visited[w]) {//为该邻接点初始化为结点CSTree p=(CSTree)malloc(sizeof(CSNode));p->data=G.vexs[w];p->lchild=NULL;p->nextsibling=NULL;//该结点的第一个邻接点作为孩子结点，其它邻接点作为孩子结点的兄弟结点if (first) {(*T)->lchild=p;first=false;}//否则，为兄弟结点else{q->nextsibling=p;}q=p;//以当前访问的顶点为树根，继续访问其邻接点DFSTree(G, w, &q);}}
}//深度优先搜索生成森林并转化为二叉树
void DFSForest(MGraph G,CSTree *T){(*T)=NULL;//每个顶点的标记为初始化为falsefor (int v=0; v<G.vexnum; v++) {visited[v]=false;}CSTree q=NULL;//遍历每个顶点作为初始点，建立深度优先生成树for (int v=0; v<G.vexnum; v++) {//如果该顶点的标记位为false，证明未访问过if (!(visited[v])) {//新建一个结点，表示该顶点CSTree p=(CSTree)malloc(sizeof(CSNode));p->data=G.vexs[v];p->lchild=NULL;p->nextsibling=NULL;//如果树未空，则该顶点作为树的树根if (!(*T)) {(*T)=p;          }//该顶点作为树根的兄弟结点else{q->nextsibling=p;}//每次都要把q指针指向新的结点，为下次添加结点做铺垫q=p;//以该结点为起始点，构建深度优先生成树DFSTree(G,v,&p);}}
}//前序遍历二叉树
void PreOrderTraverse(CSTree T){if (T) {printf("%d ",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->nextsibling);}return;
}int main() {MGraph G;//建立一个图的变量CreateDN(&G);//初始化图CSTree T;DFSForest(G, &T);PreOrderTraverse(T);return 0;
}

图中，3 种颜色的树各代表一棵深度优先生成树，使用孩子兄弟表示法表示，也就是将三棵树的树根相连，第一棵树的树根作为整棵树的树根。

4.广度优先生成森林

非连通图采用广度优先搜索算法进行遍历时，经过的顶点以及边的集合为该图的广度优先生成森林。

拿图 4（a）中的非连通图为例，通过广度优先搜索得到的广度优先生成森林用孩子兄弟表示法为：

实现代码为：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERtEX_NUM 20                   //顶点的最大个数
#define VRType int                          //表示顶点之间的关系的变量类型
#define InfoType char                       //存储弧或者边额外信息的指针变量类型
#define VertexType int                      //图中顶点的数据类型typedef enum{false,true}bool;               //定义bool型常量bool visited[MAX_VERtEX_NUM];               //设置全局数组，记录标记顶点是否被访问过typedef struct {VRType adj;                             //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值。InfoType * info;                        //弧或边额外含有的信息指针
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];typedef struct {VertexType vexs[MAX_VERtEX_NUM];        //存储图中顶点数据AdjMatrix arcs;                         //二维数组，记录顶点之间的关系int vexnum,arcnum;                      //记录图的顶点数和弧（边）数
}MGraph;typedef struct CSNode{VertexType data;struct CSNode * lchild;//孩子结点struct CSNode * nextsibling;//兄弟结点
}*CSTree,CSNode;typedef struct Queue{CSTree data;//队列中存放的为树结点struct Queue * next;
}Queue;//根据顶点本身数据，判断出顶点在二维数组中的位置
int LocateVex(MGraph * G,VertexType v){int i=0;//遍历一维数组，找到变量vfor (; i<G->vexnum; i++) {if (G->vexs[i]==v) {break;}}//如果找不到，输出提示语句，返回-1if (i>G->vexnum) {printf("no such vertex.\n");return -1;}return i;
}//构造无向图
void CreateDN(MGraph *G){scanf("%d,%d",&(G->vexnum),&(G->arcnum));for (int i=0; i<G->vexnum; i++) {scanf("%d",&(G->vexs[i]));}for (int i=0; i<G->vexnum; i++) {for (int j=0; j<G->vexnum; j++) {G->arcs[i][j].adj=0;G->arcs[i][j].info=NULL;}}for (int i=0; i<G->arcnum; i++) {int v1,v2;scanf("%d,%d",&v1,&v2);int n=LocateVex(G, v1);int m=LocateVex(G, v2);if (m==-1 ||n==-1) {printf("no this vertex\n");return;}G->arcs[n][m].adj=1;G->arcs[m][n].adj=1;//无向图的二阶矩阵沿主对角线对称}
}int FirstAdjVex(MGraph G,int v)
{//查找与数组下标为v的顶点之间有边的顶点，返回它在数组中的下标for(int i = 0; i<G.vexnum; i++){if( G.arcs[v][i].adj ){return i;}}return -1;
}int NextAdjVex(MGraph G,int v,int w)
{//从前一个访问位置w的下一个位置开始，查找之间有边的顶点for(int i = w+1; i<G.vexnum; i++){if(G.arcs[v][i].adj){return i;}}return -1;
}//初始化队列
void InitQueue(Queue ** Q){(*Q)=(Queue*)malloc(sizeof(Queue));(*Q)->next=NULL;
}//结点v进队列
void EnQueue(Queue **Q,CSTree T){Queue * element=(Queue*)malloc(sizeof(Queue));element->data=T;element->next=NULL;Queue * temp=(*Q);while (temp->next!=NULL) {temp=temp->next;}temp->next=element;
}//队头元素出队列
void DeQueue(Queue **Q,CSTree *u){(*u)=(*Q)->next->data;(*Q)->next=(*Q)->next->next;
}//判断队列是否为空
bool QueueEmpty(Queue *Q){if (Q->next==NULL) {return true;}return false;
}void BFSTree(MGraph G,int v,CSTree*T){CSTree q=NULL;Queue * Q;InitQueue(&Q);//根结点入队EnQueue(&Q, (*T));//当队列为空时，证明遍历完成while (!QueueEmpty(Q)) {bool first=true;//队列首个结点出队DeQueue(&Q,&q);//判断结点中的数据在数组中的具体位置int v=LocateVex(&G,q->data);//已经访问过的更改其标志位visited[v]=true;//遍历以出队结点为起始点的所有邻接点for (int w=FirstAdjVex(G,v); w>=0; w=NextAdjVex(G,v, w)) {//标志位为false，证明未遍历过if (!visited[w]) {//新建一个结点 p，存放当前遍历的顶点CSTree p=(CSTree)malloc(sizeof(CSNode));p->data=G.vexs[w];p->lchild=NULL;p->nextsibling=NULL;//当前结点入队EnQueue(&Q, p);//更改标志位visited[w]=true;//如果是出队顶点的第一个邻接点，设置p结点为其左孩子if (first) {q->lchild=p;first=false;}//否则设置其为兄弟结点else{q->nextsibling=p;}q=p;}}}
}//广度优先搜索生成森林并转化为二叉树
void BFSForest(MGraph G,CSTree *T){(*T)=NULL;//每个顶点的标记为初始化为falsefor (int v=0; v<G.vexnum; v++) {visited[v]=false;}CSTree q=NULL;//遍历图中所有的顶点for (int v=0; v<G.vexnum; v++) {//如果该顶点的标记位为false，证明未访问过if (!(visited[v])) {//新建一个结点，表示该顶点CSTree p=(CSTree)malloc(sizeof(CSNode));p->data=G.vexs[v];p->lchild=NULL;p->nextsibling=NULL;//如果树未空，则该顶点作为树的树根if (!(*T)) {(*T)=p;}//该顶点作为树根的兄弟结点else{q->nextsibling=p;}//每次都要把q指针指向新的结点，为下次添加结点做铺垫q=p;//以该结点为起始点，构建广度优先生成树BFSTree(G,v,&p);}}
}//前序遍历二叉树
void PreOrderTraverse(CSTree T){if (T) {printf("%d ",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->nextsibling);}return;
}int main() {MGraph G;//建立一个图的变量CreateDN(&G);//初始化图CSTree T;BFSForest(G, &T);PreOrderTraverse(T);return 0;
}

二、几个特别NB的算法详解

1.普里姆算法(Prim算法)求最小生成树

通过前面的学习，对于含有 n 个顶点的连通图来说可能包含有多种生成树，例如图 1 所示：

图 1 中的连通图和它相对应的生成树，可以用于解决实际生活中的问题：

假设A、B、C 和 D 为 4 座城市，为了方便生产生活，要为这 4 座城市建立通信。

对于 4 个城市来讲，本着节约经费的原则，只需要建立 3 个通信线路即可，就如图 1（b）中的任意一种方式。

在具体选择采用（b）中哪一种方式时，需要综合考虑城市之间间隔的距离，建设通信线路的难度等各种因素，将这些因素综合起来用一个数值表示，当作这条线路的权值。

假设通过综合分析，城市之间的权值如图 2（a）所示，对于（b）的方案中，选择权值总和为 7 的两种方案最节约经费。

这就是要讨论的最小生成树的问题，简单得理解就是给定一个带有权值的连通图（连通网），如何从众多的生成树中筛选出权值总和最小的生成树，即为该图的最小生成树。

普里姆算法
给定一个连通网，求最小生成树的方法有：普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法。
普里姆算法在找最小生成树时，将顶点分为两类，一类是在查找的过程中已经包含在树中的（假设为 A 类），剩下的是另一类（假设为 B 类）。
对于给定的连通网，起始状态全部顶点都归为 B 类。
在找最小生成树时，选定任意一个顶点作为起始点，并将之从 B 类移至 A 类；
然后找出 B 类中到 A 类中的顶点之间权值最小的顶点，将之从 B 类移至 A 类
如此重复，直到 B 类中没有顶点为止。所走过的顶点和边就是该连通图的最小生成树。
例如，通过普里姆算法查找图 2（a）的最小生成树的步骤为：
假如从顶点A出发，顶点 B、C、D 到顶点 A 的权值分别为 2、4、2，所以，对于顶点 A 来说，顶点 B 和顶点 D 到 A 的权值最小，假设先找到的顶点 B：

继续分析顶点 C 和 D，顶点 C 到 B 的权值为 3，到 A 的权值为 4；
顶点 D 到 A 的权值为 2，到 B 的权值为无穷大（如果之间没有直接通路，设定权值为无穷大）。
所以顶点 D 到 A 的权值最小：

最后，只剩下顶点 C，到 A 的权值为 4，到 B 的权值和到 D 的权值一样大，为 3。所以该连通图有两个最小生成树：

#include <stdio.h>
#include <stdlib.h>
#define VertexType int
#define VRType int
#define MAX_VERtEX_NUM 20
#define InfoType char
#define INFINITY 65535typedef struct {VRType adj;                             //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值。InfoType * info;                        //弧额外含有的信息指针
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];typedef struct {VertexType vexs[MAX_VERtEX_NUM];        //存储图中顶点数据AdjMatrix arcs;                         //二维数组，记录顶点之间的关系int vexnum,arcnum;                      //记录图的顶点数和弧（边）数
}MGraph;//根据顶点本身数据，判断出顶点在二维数组中的位置
int LocateVex(MGraph G,VertexType v){int i=0;//遍历一维数组，找到变量vfor (; i<G.vexnum; i++) {if (G.vexs[i]==v) {return i;}}return -1;
}//构造无向网
void CreateUDN(MGraph* G){scanf("%d,%d",&(G->vexnum),&(G->arcnum));for (int i=0; i<G->vexnum; i++) {scanf("%d",&(G->vexs[i]));}for (int i=0; i<G->vexnum; i++) {for (int j=0; j<G->vexnum; j++) {G->arcs[i][j].adj=INFINITY;G->arcs[i][j].info=NULL;}}for (int i=0; i<G->arcnum; i++) {int v1,v2,w;scanf("%d,%d,%d",&v1,&v2,&w);int m=LocateVex(*G, v1);int n=LocateVex(*G, v2);if (m==-1 ||n==-1) {printf("no this vertex\n");return;}G->arcs[n][m].adj=w;G->arcs[m][n].adj=w;}
}//辅助数组，用于每次筛选出权值最小的边的邻接点
typedef struct {VertexType adjvex;//记录权值最小的边的起始点VRType lowcost;//记录该边的权值
}closedge[MAX_VERtEX_NUM];
closedge theclose;//创建一个全局数组，因为每个函数中都会使用到//在辅助数组中找出权值最小的边的数组下标，就可以间接找到此边的终点顶点。
int minimun(MGraph G,closedge close){int min=INFINITY;int min_i=-1;for (int i=0; i<G.vexnum; i++) {//权值为0，说明顶点已经归入最小生成树中；然后每次和min变量进行比较，最后找出最小的。if (close[i].lowcost>0 && close[i].lowcost < min) {min=close[i].lowcost;min_i=i;}}//返回最小权值所在的数组下标return min_i;
}//普里姆算法函数，G为无向网，u为在网中选择的任意顶点作为起始点
void miniSpanTreePrim(MGraph G,VertexType u){//找到该起始点在顶点数组中的位置下标int k=LocateVex(G, u);//首先将与该起始点相关的所有边的信息：边的起始点和权值，存入辅助数组中相应的位置，例如（1，2）边，adjvex为0，lowcost为6，存入theclose[1]中，辅助数组的下标表示该边的顶点2for (int i=0; i<G.vexnum; i++) {if (i !=k) {theclose[i].adjvex=k;theclose[i].lowcost=G.arcs[k][i].adj;}}//由于起始点已经归为最小生成树，所以辅助数组对应位置的权值为0，这样，遍历时就不会被选中theclose[k].lowcost=0;//选择下一个点，并更新辅助数组中的信息for (int i=1; i<G.vexnum; i++) {//找出权值最小的边所在数组下标k=minimun(G, theclose);//输出选择的路径printf("v%d v%d\n",G.vexs[theclose[k].adjvex],G.vexs[k]);//归入最小生成树的顶点的辅助数组中的权值设为0theclose[k].lowcost=0;//信息辅助数组中存储的信息，由于此时树中新加入了一个顶点，需要判断，由此顶点出发，到达其它各顶点的权值是否比之前记录的权值还要小，如果还小，则更新for (int j=0; j<G.vexnum; j++) {if (G.arcs[k][j].adj<theclose[j].lowcost) {theclose[j].adjvex=k;theclose[j].lowcost=G.arcs[k][j].adj;}}}printf("\n");
}int main(){MGraph G;CreateUDN(&G);miniSpanTreePrim(G, 1);
}

2.克鲁斯卡尔算法(Kruskal算法)求最小生成树

3.拓扑排序算法

4.迪杰斯特拉(Dijkstra算法)算法

5.弗洛伊德算法

2，3，4，5算法详解请点击：https://blog.csdn.net/wolfGuiDao/article/details/107593373