Prim算法、Kruskal算法和Dijkstra…

最新推荐文章于 2023-12-06 19:02:29 发布

Rachel-Zhang3

最新推荐文章于 2023-12-06 19:02:29 发布

阅读量1.4k

点赞数 1

分类专栏：笔试面试题复习

本文链接：https://blog.csdn.net/rxm1989/article/details/39550531

版权

笔试面试题复习专栏收录该内容

33 篇文章 0 订阅

订阅专栏

本文转自：http://squirrelrao.iteye.com/blog/1044867

Prim算法和Kruskal算法都能从连通图找出最小生成树。区别在于Prim算法是挨个找，而Kruskal是先排序再找。

一、Prim算法：

Prim算法实现的是找出一个有权重连通图中的最小生成树，即：具有最小权重且连接到所有结点的树。(强调的是树，树是没有回路的)。

Prim算法是这样来做的：

首先以一个结点作为最小生成树的初始结点，然后以迭代的方式找出与最小生成树中各结点权重最小边，并加入到最小生成树中。加入之后如果产生回路则跳过这条边，选择下一个结点。当所有结点都加入到最小生成树中之后，就找出了连通图中的最小生成树了。

Prim算法最小生成树查找过程：

C语言实现：

     C代码  
     
     
      
   
 #include   
 　　#include   
 　　#define maxint 1073741824  
 　　int main()  
 　　{  
 　　FILE *input=fopen("input.txt","r"),*out=fopen("output.txt","w");  
 　　int n,m,i,j,x,y,w;  
 　　fscanf(input,"%d %d",&n,&m);  
 　　int map[n][n],E[m][3],tree[m],Mst[n][n];  
 　　  
 　　memset(tree,0,sizeof(tree));  
 　　for(i=0; i
 　　{  
 　　for(j=0; j
 　　{  
 　　map[i][j]=maxint;  
 　　Mst[i][j]=maxint;  
 　　}  
 　　E[i][0]=E[i][1]=maxint;  
 　　}  
 　　for(i=0; i
 　　{  
 　　fscanf(input,"%d %d %d",&x,&y,&w);  
 　　if(w
 　　{  
 　　map[x][y]=w;  
 　　map[y][x]=w;  
 　　}  
 　　}  
 　　int min=maxint,next=0,now=0,k=0;  
 　　tree[0]=1;  
 　　for(i=0; i
 　　{  
 　　for(j=0; j
 　　{  
 　　if(map[now][j]!=maxint && tree[j]==0)  
 　　{  
 　　E[k][0]=now;  
 　　E[k][2]=map[now][j];  
 　　E[k++][1]=j;  
 　　}  
 　　}  
 　　for(j=0; j
 　　{  
 　　if(E[j][2]
 　　{  
 　　min=E[j][2];  
 　　x=E[j][0];  
 　　y=E[j][1];  
 　　next=y;  
 　　}  
 　　}  
 　　tree[next]=1;  
 　　now=next;  
 　　Mst[x][y]=map[x][y];  
 　　Mst[y][x]=map[y][x];  
 　　min=maxint;  
 　　}  
 　　for(i=0; i
 　　{  
 　　for(j=0; j
 　　{  
 　　if(Mst[i][j]==maxint) //判断两点是否连通  
 　　fprintf(out,"00 "); //美化输出，不必多加探究  
 　　else  
 　　{  
 　　fprintf(out,"%d ",Mst[i][j]); //输出生成树的邻接矩阵，要输出树的自己可以根据邻接矩阵的数据进行加工  
 　　}  
 　　}  
 　　fprintf(out,"\n");  
 　　}  
 　　fclose(input);  
 　　fclose(out);  
 　　return 0;  
 　　} // 程序未考虑不是连通图的情况，修改很简单，判断生成树的节点数量是否等于原图的节点数量  
 　　//如果小于（不会有大于）则本图不是连通图  
 　　//其实prim和迪杰斯特拉算法核心有相似之处  

二、Kruskal算法：

Kruskal算法与Prim算法的不同之处在于，Kruskal在找最小生成树结点之前，需要对所有权重边做从小到大排序。将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。当所有结点都加入到最小生成树中之后，就找出了最小生成树。

C语言实现：

     C代码  
     
   
 
       
 　　  
 　　#include "stdio.h"  
 　　#define maxver 10  
 　　#define maxright 100  
 　　int G[maxver][maxver],record=0,touched[maxver][maxver];  
 　　int circle=0;  
 　　int FindCircle(int,int,int,int);  
 　　int main()  
 　　{  
 　　int path[maxver][2],used[maxver][maxver];  
 　　int i,j,k,t,min=maxright,exsit=0;  
 　　int v1,v2,num,temp,status=0;  
 　　restart:  
 　　printf("Please enter the number of vertex(s) in the graph:\n");  
 　　scanf("%d",&num);  
 　　if(num>maxver||num<0)  
 　　{  
 　　printf("Error!Please reinput!\n");  
 　　goto restart;  
 　　}  
 　　for(j=0;j<num;j++)  
 　　for(k=0;k<num;k++)  
 　　{  
 　　if(j==k)  
 　　{  
 　　G[j][k]=maxright;  
 　　used[j][k]=1;  
 　　touched[j][k]=0;  
 　　}  
 　　else  
 　　if(j<k)  
 　　{  
 　　re:  
 　　printf("Please input the right between vertex %d and vertex %d,if no edge exists please input -1:\n",j+1,k+1);  
 　　scanf("%d",&temp);  
 　　if(temp>=maxright||temp<-1)  
 　　{  
 　　printf("Invalid input!\n");  
 　　goto re;  
 　　}  
 　　if(temp==-1)  
 　　temp=maxright;  
 　　G[j][k]=G[k][j]=temp;  
 　　used[j][k]=used[k][j]=0;  
 　　touched[j][k]=touched[k][j]=0;  
 　　}  
 　　}  
 　　for(j=0;j<num;j++)  
 　　{  
 　　path[j][0]=0;  
 　　path[j][1]=0;  
 　　}  
 　　for(j=0;j<num;j++)  
 　　{  
 　　status=0;  
 　　for(k=0;k<num;k++)  
 　　if(G[j][k]<maxright)  
 　　{  
 　　status=1;  
 　　break;  
 　　}  
 　　if(status==0)  
 　　break;  
 　　}  
 　　for(i=0;i<num-1&&status;i++)  
 　　{  
 　　for(j=0;j<num;j++)  
 　　for(k=0;k<num;k++)  
 　　if(G[j][k]<min&&!used[j][k])  
 　　{  
 　　v1=j;  
 　　v2=k;  
 　　min=G[j][k];  
 　　}  
 　　if(!used[v1][v2])  
 　　{  
 　　used[v1][v2]=1;  
 　　used[v2][v1]=1;  
 　　touched[v1][v2]=1;  
 　　touched[v2][v1]=1;  
 　　path[0]=v1;  
 　　path[1]=v2;  
 　　for(t=0;t<record;t++)  
 　　FindCircle(path[t][0],path[t][0],num,path[t][0]);  
 　　if(circle)  
 　　{  
 　　circle=0;  
 　　i--;  
 　　exsit=0;  
 　　touched[v1][v2]=0;  
 　　touched[v2][v1]=0;  
 　　min=maxright;  
 　　}  
 　　else  
 　　{  
 　　record++;  
 　　min=maxright;  
 　　}  
 　　}  
 　　}  
 　　if(!status)  
 　　printf("We cannot deal with it because the graph is not connected!\n");  
 　　else  
 　　{  
 　　for(i=0;i<num-1;i++)  
 　　printf("Path %d:vertex %d to vertex %d\n",i+1,path[0]+1,path[1]+1);  
 　　}  
 　　return 1;  
 　　}  
 　　int FindCircle(int start,int begin,int times,int pre)  
 　　{   
 　　int i;  
 　　for(i=0;i<times;i++)  
 　　if(touched[begin]==1)  
 　　{  
 　　if(i==start&&pre!=start)  
 　　{  
 　　circle=1;  
 　　return 1;  
 　　break;  
 　　}  
 　　else  
 　　if(pre!=i)  
 　　FindCircle(start,i,times,begin);  
 　　else  
 　　continue;  
 　　}  
 　　return 1;  
 　　}  
 
   
   无疑，Kruskal算法在效率上要比Prim算法快，因为Kruskal只需要对权重边做一次排序，而Prim算法则需要做多次排序。尽管Prim算法每次做的算法涉及的权重边不一定会涵盖连通图中的所有边，但是随着所使用的排序算法的效率的提高，Kruskal算法和Prim算法之间的差异将会清晰的显性出来。
 
 
 
   
 
  
 Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。
 Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。　
 算法思想
 Dijkstra算法思想为：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将 加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
 2.3  Dijkstra算法具体步骤　　
 （1）初始时，S只包含源点，即S＝，v的距离为0。U包含除v外的其他顶点，U中顶点u距离为边上的权（若v与u有边）或 ）（若u不是v的出边邻接点）。
 （2）从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。
 （3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u（u U）的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。
 （4）重复步骤（2）和（3）直到所有顶点都包含在S中。
 2.4  Dijkstra算法举例说明
 如下图，设A为源点，求A到其他各顶点（B、C、D、E、F）的最短路径。线上所标注为相邻线段之间的距离，即权值。（注：此图为随意所画，其相邻顶点间的距离与图中的目视长度不能一一对等）
 
 图一：Dijkstra无向图
  
 算法执行步骤如下表：【注：图片要是看不到请到“相册--日志相册”中，名为“Dijkstra算法过程”的图就是了】
  