prim算法两种实现方法

 顶点为:A,B,C,D,E,F    具体顶点的组成结构可以参考：数据结构（严蔚敏版）的图

第一种：贪心法

#include <stdio.h>
#define N 6
#define M 9999 //代表不可达

//初始图N=（V，{E}）

TanXinPrim()
{
   // int Matrix[N][N];
    int i,j,count;//count用于记录T中的顶点个数，count<=T
    int flag[N];
    //初始化矩阵
    int Matrix[N][N]={{M,6,1,5,M,M},{6,M,5,M,3,M},{1,5,M,5,6,4},{5,M,5,M,M,2},{M,3,6,M,M,6},{M,M,4,2,6,M}};
    //初始化最小生成树
    for(i=0;i<N;i++)
        flag[i]=0;
    //T的初始条件，任意选取一点加入T中,T=(U,{空边集})
    //U={u0}
    flag[0]=1;
    count=1;//T的顶点数目为1
    while(count<N){
    int m,n,min;
    m=-1;
    n=-1;
    min=999;
    //找出一条（u',v'）最短的边,然后把边（u',v'）和顶点v'加入T中，
    //其中u'属于U，v'属于集合V-U中
    for(i=0;i<N;i++){
        //找出集合U中点，到集合V-U中点的最小边
        if(flag[i]){
            for(j=0;j<N;j++)
                if(!flag[j]){
                    if(Matrix[i][j]<min){
                        min=Matrix[i][j];
                        m=i;
                        n=j;
                    }

                }
        }
    }
    flag[n]=1;
    count++;
    printf("%c->%c:%d\n",(m+65),(n+65),min);
    }
}

int main()
{
    TanXinPrim();
    return 1;
}

算法时间复杂度：O(n^3)

第2种:算法书上常用算法(如:数据结构严蔚敏版上面所讲)

#include <stdio.h>
#define N 6
#define M 999

prim(){
// 初始化图
int matrix[N][N]={{M,6,1,5,M,M},{6,M,5,M,3,M},{1,5,M,5,6,4},{5,M,5,M,M,2},{M,3,6,M,M,6},{M,M,4,2,6,M}};
int i,j;
int count;
int nearest[N],adjacent[N];
//初始化标志数组
int flag[N];
for(i=0;i<N;i++)
    flag[i]=0;
//初始化最小生成树
//初始化用于存储最短边和邻接点的数组nearest[N],adjacent[N]
flag[0]=1;
for(i=1;i<N;i++)
    {
        nearest[i]=matrix[0][i];
        adjacent[i]=0;
    }
count=5;
printf("This is right!\n");
while(count--){
    int min;
    int index;
    min=M;
    index=-1;
    //找出nearest[i]中最短的边
    for(i=0;i<N;i++){
        if(!flag[i]&&(nearest[i]<min)){
            min=nearest[i];
            index=i;
        }
    }
    //输出加入最小生成树的点和其对应的最短边
    printf("%c->%c:%d\n",(adjacent[index]+65),(index+65),min);
    //将加入最小生成树中的index点，做加入标记
    flag[index]=1;
    //修改最短边数组和邻接点数组
    for(i=0;i<N;i++){
        if(!flag[i]&&(matrix[index][i]<nearest[i])){
            nearest[i]=matrix[index][i];
            adjacent[i]=index;
        }
    }

}
}

int main()
{
    prim();
    return 1;
}

算法时间复杂度:O(n^2)