圖的鄰接矩陣表示方式——最小生成樹算法prim&&Kruskal

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define NO 0
#define FALSE 0
#define TRUE 1
#define ERROR -1 

#define INFINITY 200000
#define MAX_VERTEX_NUM 20

typedef int *SetType;
typedef int Status;
typedef int VRType;//圖、表頂點關系類型
typedef struct ArcCell
{
    VRType adj;  //權值
}ArcCell;

typedef ArcCell AdjMaxtrix[MAX_VERTEX_NUM+1][MAX_VERTEX_NUM+1];//鄰接矩陣
typedef char VertexType_M;//圖的頂點類型


typedef struct 
{
    VertexType_M vexs[MAX_VERTEX_NUM+1];//頂點向量
    AdjMaxtrix arcs;
    int vexnum,arcnum;
}MGraph;

//作用非常的重要,主要是為了實現記錄每一個結點的前一個結點以及它們之間的權重
typedef struct 
{
    VertexType_M adjvex;//較早加入當前邊的端點
    VRType lowcost;//當前邊的權值

}Edge;

typedef struct  //定義一個邊集用來存儲圖的所有邊信息
{
    int begin,end;
    int weight;
}gEdge;


Status visited[MAX_VERTEX_NUM+1];

Status CreateUDN_M(MGraph *G);

void OutputMGraph(MGraph G);

int LocateVex_M(MGraph G,VertexType_M u);

int MinSpanTree_PRIM(MGraph G,VertexType_M u);

int Minimum(Edge closedge[],int n);

void MinSpanTree_KRUSKAL(MGraph G);


gEdge *CreateEdges(MGraph G);//生成圖的排序過的邊集數組

int main(int argc,char** argv){
    MGraph G;
    printf("初始化並輸出無向網..\n");
    {
        CreateUDN_M(&G);

        OutputMGraph(G);
        printf("\n");
    }
    printf("函數 MinSpanTree_PRIM 測試..\n");
    {
        int total;

        printf("普里姆算法..\n");
        printf("先后加入最小生成樹的各結點及其對應的最小邊的權值分別為： \n");
        total=MinSpanTree_PRIM(G,'A');
        printf("\n");
        printf("輸出最小生成樹的總長度為%d\n",total);
        printf("\n");
    }
    printf("函數 MinSpanTree_KRUSKAL 測試..\n");
    {
        printf("克魯斯卡爾算法..\n");
        printf("最小生成樹的各邊及其對應的權值分別為：\n");
        MinSpanTree_KRUSKAL(G);
        printf("\n");
    }


    return 0;
}
Status CreateUDN_M(MGraph *G){
    int i,j,k;
    VertexType_M v1,v2;
    VRType w;
    printf("輸入頂點數 ");
    scanf("%d",&(G->vexnum));
    printf("輸入弧數 ");
    scanf("%d",&(G->arcnum));
    printf("輸入各個頂點值 ");
    getchar();
    for(i=1;i<=G->vexnum;i++)
    {
        scanf("%c",&(G->vexs[i]));    
    }
    
    printf("初始化鄰接矩陣\n");
    for(i=1;i<=G->vexnum;i++)
    {
        for(j=1;j<=G->vexnum;j++)
            G->arcs[i][j].adj=INFINITY;
    }
    for(k=1;k<=G->arcnum;k++)
    {
        getchar();
        printf("輸入相鄰結點（添加弧的信息）");
        scanf("%c%c%d",&v1,&v2,&w);
        i=LocateVex_M(*G,v1);
        j=LocateVex_M(*G,v2);
        
        G->arcs[i][j].adj=w;
        G->arcs[j][i]=G->arcs[i][j];
        }


return OK;
}

int LocateVex_M(MGraph G,VertexType_M u)
{
    int i;
    for(i=1;i<=G.vexnum;i++)
    {
        if(G.vexs[i]==u)
            return i;
    }
    return 0;

}


void OutputMGraph(MGraph G){
    int i,j;
    if(!G.vexnum&&!G.arcnum)
        printf("空圖（表）！\n");
    else
    {
        printf(" ");
        for(i=1;i<=G.vexnum;i++)
        {
            printf("%3c",G.vexs[i]);
        }
        printf("\n");
        for(i=1;i<=G.vexnum;i++)
        {
            printf("%c",G.vexs[i]);
            for(j=1;j<=G.vexnum;j++)
            {
                if(G.arcs[i][j].adj==INFINITY)
                    printf(" ∞");
                else
                    printf("%3d",G.arcs[i][j]);
            }
            printf("\n");
                
        }
    }
}

/*Prim算法：
本質上是貪心算法，首先輸入一個頂點作為起點，提取這個頂點的序號，然后有一個closedge數組來初始化，遍歷之后將每個頂點的
前一個訪問的結點初始化為u,並且將他們之間的弧的權重直接當成二者之間的權重。然后首先輸出一個u.Minmum這個函數主要是用來
求出所有的邊中和u相連的弧的權重最小的頂點值(第一個循環的時候),然后輸出這個最小的權值以及頂點。並且將這個頂點的標記為
lowcast=0；在后面的訪問中就不會用到這個頂點。之后由於這個時候已知的頂點是兩個，因此對於所有和第二個結點中連接弧長最小
的頂點，需要改變弧的權值以及前一個頂點的位置。然后第二輪循環進來的時候，同樣在Minmum這個函數中實現找出所有哦沒有被訪問
過的權值最小的頂點，這個時候不需要擔心會訪問非前面兩個鄰接點，因為如果不是鄰接點，它們的弧的權重將是無窮大，因此肯定會
訪問權值最小的結點。然后循環將每一個結點都輸出。*/

int MinSpanTree_PRIM(MGraph G,VertexType_M u){
    int i,j,k;
    int total=0;
    Edge closedge[G.vexnum+1];
    k=LocateVex_M(G,u);
    /*將輔助矩陣初始化使每一個結點都標記為前一個結點是u,並且它們之間的距離是無窮大，若是鄰接點那么就是adj的值*/
    for(j=1;j<=G.vexnum;j++)
    {
        if(j!=k)
        {
            closedge[j].adjvex=u;  //標記j這個頂點的前一個頂點的信息
            closedge[j].lowcost=G.arcs[k][j].adj;
        }
    }
    closedge[k].lowcost=0; //自己到自己的cost標記為0
    printf("    %c\n", u);
    for(i=1;i<=G.vexnum-1;i++)//總共需要這么多此找出最小邊
    {
        k=Minimum(closedge,G.vexnum);
        total+=closedge[k].lowcost;
        printf("%2d,%c\n",closedge[k].lowcost,G.vexs[k]);
        closedge[k].lowcost=0;
        for(j=1;j<=G.vexnum;j++)
        {
            if(G.arcs[k][j].adj<closedge[j].lowcost)
            {
                closedge[j].adjvex=G.vexs[k];
                closedge[j].lowcost=G.arcs[k][j].adj;
            }
        }
    }
    return total;
}

//找到所有和結點鄰接的點中權值最小的並且返回j（用來標記最小的值所在的下標）
int Minimum(Edge closedge[],int n){
    int i,j;
    int min=INFINITY;
    i=1;
    j=0;
    for(;i<=n;i++){
        if(closedge[i].lowcost)//從權值不為0的邊中選擇擁有最小權值的邊
        {
            if(closedge[i].lowcost<=min)
            {
                min=closedge[i].lowcost;
                j=i;
            }
        }
    }
    return j;
}

gEdge *CreateEdges(MGraph G){
    int i,j;
    int k=1;
    int EdgeNum=G.arcnum;
    int VertexNum=G.vexnum;
    gEdge temp;
    gEdge *p=(gEdge*)malloc(sizeof(gEdge)*VertexNum*VertexNum);   //之前程序報錯 是因為申請的空間不夠大，越界了
    
     for(i=1;i<=VertexNum;i++) //邊集數組初始化
         for(j=i;j<=VertexNum;j++) //為了避免無向圖的每條邊被記錄兩次，只考慮上三角矩陣
             if(G.arcs[i][j].adj!=0&&G.arcs[i][j].adj!=INFINITY){
                 p[k].begin=i;
                 p[k].end=j;
                 p[k].weight=G.arcs[i][j].adj;
                 k++;
             }
            //首個p[i]與后面i+1……最后個依次比較，每一次都將小的放在第i個
    for(i=1;i<EdgeNum;i++)//對邊集數組進行選擇排序
        for(j=i+1;j<=EdgeNum;j++)
            if(p[i].weight>p[j].weight){
                 // temp.begin=p[i].begin;
                 // temp.end=p[i].end;
                 // temp.weight=p[i].weight;


                temp=p[i];
                p[i]=p[j];
                p[j]=temp;
            }
    return p; //這個時候返回的p是已經從小到大排好序的，並且擁有一共EdgeNumt個大小的數組
}

void MinSpanTree_KRUSKAL(MGraph G){
     int VertexNum=G.vexnum;
     int EdgeNum=G.arcnum;
     gEdge *p=CreateEdges(G);//邊數組
     int *index=(int*)malloc(sizeof(int)*VertexNum);
     //index 數組，其元素為連通分量的編號，index[i]=index[j]表示編號為i,j的頂點在一個連通分量里
     int *MSTEdge = (int *)malloc(sizeof(int)*VertexNum); //用來存儲已經確定的MST的邊的編號共VertexNum-1條邊
     int k=1;
    int WeightSum=0;
     int IndexBegin,IndexEnd;
     int i,j,n;



     for(i=1;i<=VertexNum;i++) //初始化所有的index=-1;
         index[i]=-1;

    for(i=1;i<VertexNum;i++)
    {
        for(j=1;j<=EdgeNum;j++)
        {
            if(!(index[p[j].begin]>=0&&index[p[j].end]>=0&&index[p[j].begin]==index[p[j].end])){//找到當前還沒有加入到同一個連通分量權值最小的邊
                MSTEdge[i]=j;   //將每一個不同的弧復制給MSTEdge 一共有VertexNum條邊
                if((index[p[j].begin]==-1)&&(index[p[j].end]==-1))
                    index[p[j].begin]=index[p[j].end]=i;//將兩個點之間直接連通
                else if((index[p[j].begin]==-1)&&(index[p[j].end]>=0)){
                    index[p[j].begin]=i;
                    IndexEnd=index[p[j].end];
                    for(n=1;n<=VertexNum;n++)
                        if(index[n]==IndexEnd)
                            index[n]=i;       
                        //如果j這條弧中，有一個結點已經被連通，但是另一個結點還沒有被連通，那么這個時候因為這個時候
                        //要加入這一段弧，因此相當於將這兩個結點連接起來，因此我們就直接把，和另一個結點連接的所有的相同的結點都幅值為i

                }        
                else  if((index[p[j].end]==-1)&&(index[p[j].begin]>=0))
                {
                    index[p[j].end]=i;
                    IndexBegin=index[p[j].begin];
                    for(n=1;n<=VertexNum;n++)
                    {
                        if(index[n]==IndexBegin)
                            index[n]=i;
                    }

                }
                else   //也就是兩個結點都被包含進去了 但是還沒有連通 
                {
                    IndexEnd=index[p[j].end];
                    IndexBegin=index[p[j].begin];
                    for(n=1;n<=VertexNum;n++)
                    {
                        if(index[n]==IndexBegin||index[n]==IndexEnd)
                            index[n]=i;
                    }

                }
                break;  
                //里面執行完一次之后直接跳出循環，i進入下一條邊，而j仍然從0開始，而之前幅值過的邊不會再進去
                //因此能夠保證進去的邊第一次，而對於新的邊中如果兩個結點已經是同一個集合中的元素，也不會再進去

            }
        }
    }




     printf("MTS的邊為：\n");
     for(i=1;i<VertexNum;i++){
         printf("%c--%c\n",G.vexs[p[MSTEdge[i]].begin],G.vexs[p[MSTEdge[i]].end]);
         WeightSum+=p[MSTEdge[i]].weight;
     }
    printf("MST的值為：%d\n",WeightSum);

}

 

 

參考 http://www.cnblogs.com/kangjianwei101/p/5222014.html

http://blog.csdn.net/u014488381/article/details/41447229