最小生成樹算法代碼

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#define MAX_VERTEX_NUM 20
#define OK 1
#define ERROR 0
#define MAX 1000
using namespace std;
typedef struct Arcell
{
    double adj;
}Arcell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
    char vexs[MAX_VERTEX_NUM]; //節點數組
    AdjMatrix arcs; //鄰接矩陣
    int vexnum, arcnum; //圖的當前節點數和弧數
}MGraph;
typedef struct Pnode //用於普利姆算法
{
    char adjvex; //節點
    double lowcost; //權值
}Pnode,Closedge[MAX_VERTEX_NUM]; //記錄頂點集U到V-U的代價最小的邊的輔助數組定義
typedef struct Knode //用於算法中存儲一條邊及其對應的2個節點
{
    char ch1; //節點1
    char ch2; //節點2
    double value;//權值
}Knode,Dgevalue[MAX_VERTEX_NUM];
//-----------------------------------------------------------------------------------
int CreateUDG(MGraph & G,Dgevalue & dgevalue);
int LocateVex(MGraph G,char ch);
int Minimum(MGraph G,Closedge closedge);
void MiniSpanTree_PRIM(MGraph G,char u);
void Sortdge(Dgevalue & dgevalue,MGraph G);
//-----------------------------------------------------------------------------------
int CreateUDG(MGraph & G,Dgevalue & dgevalue) //構造無向加權圖的鄰接矩陣
{
    int i,j,k;
    cout<<"請輸入圖中節點個數和邊/弧的條數：";
    cin>>G.vexnum>>G.arcnum;
    cout<<"請輸入節點：";
    for(i=0;i<G.vexnum;++i)
        cin>>G.vexs[i];
    for(i=0;i<G.vexnum;++i)//初始化數組
    {
        for(j=0;j<G.vexnum;++j)
        {
            G.arcs[i][j].adj=MAX;
        }
    }
    cout<<"請輸入一條邊依附的定點及邊的權值："<<endl;
    for(k=0;k<G.arcnum;++k)
    {
        cin >> dgevalue[k].ch1 >> dgevalue[k].ch2 >> dgevalue[k].value;
        i = LocateVex(G,dgevalue[k].ch1 );
        j = LocateVex(G,dgevalue[k].ch2 );
        G.arcs[i][j].adj = dgevalue[k].value;
        G.arcs[j][i].adj = G.arcs[i][j].adj;
    }
    return OK;
}
int LocateVex(MGraph G,char ch) //確定節點ch在圖G.vexs中的位置
{
    int a ;
    for(int i=0; i<G.vexnum; i++)
    {
        if(G.vexs[i] == ch)
            a=i;
    }
    return a;
}
//typedef struct Pnode //用於普利姆算法
//{
//    char adjvex; //節點
//    double lowcost; //權值
//}Pnode,Closedge[MAX_VERTEX_NUM]; //記錄頂點集U到V-U的代價最小的邊的輔助數組定義
void MiniSpanTree_PRIM(MGraph G,char u)//普利姆算法求最小生成樹
{
    int i,j,k;
    Closedge closedge;
    k = LocateVex(G,u);
    for(j=0; j<G.vexnum; j++)
    {
        if(j != k)
        {
            closedge[j].adjvex = u;
            closedge[j].lowcost = G.arcs[k][j].adj;
        }
    }
    closedge[k].lowcost = 0;
    for(i=1; i<G.vexnum; i++)
    {
        k = Minimum(G,closedge);
        cout<<"("<<closedge[k].adjvex<<","<<G.vexs[k]<<","<<closedge[k].lowcost<<")"<<endl;
        closedge[k].lowcost = 0;
        for(j=0; 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;
            }
        }
    }
}
int Minimum(MGraph G,Closedge closedge) //求closedge中權值最小的邊，並返回其頂點在vexs中的位置
{
    int i,j;
    double k = 1000;
    for(i=0; i<G.vexnum; i++)
    {
        if(closedge[i].lowcost != 0 && closedge[i].lowcost < k)
        {
            k = closedge[i].lowcost;
            j = i;
        }
    }
    return j;
}
void MiniSpanTree_KRSL(MGraph G,Dgevalue & dgevalue)//克魯斯卡爾算法求最小生成樹
{
    int p1,p2,i,j;
    int bj[MAX_VERTEX_NUM]; //標記數組
    for(i=0; i<G.vexnum; i++) //標記數組初始化
        bj[i]=i;
    Sortdge(dgevalue,G);//將所有權值按從小到大排序
    for(i=0; i<G.arcnum; i++)
    {
        p1 = bj[LocateVex(G,dgevalue[i].ch1)];
        p2 = bj[LocateVex(G,dgevalue[i].ch2)];
        if(p1 != p2)
        {
            cout<<"("<<dgevalue[i].ch1<<","<<dgevalue[i].ch2<<","<<dgevalue[i].value<<")"<<endl;
            for(j=0; j<G.vexnum; j++)
            {
                if(bj[j] == p2)
                    bj[j] = p1;
            }
        }
    }
}
void Sortdge(Dgevalue & dgevalue,MGraph G)//對dgevalue中各元素按權值按從小到大排序
{
    int i,j;
    double temp;
    char ch1,ch2;
    for(i=0; i<G.arcnum; i++)
    {
        for(j=i; j<G.arcnum; j++)
        {
            if(dgevalue[i].value > dgevalue[j].value)
            {
                temp = dgevalue[i].value;
                dgevalue[i].value = dgevalue[j].value;
                dgevalue[j].value = temp;
                ch1 = dgevalue[i].ch1;
                dgevalue[i].ch1 = dgevalue[j].ch1;
                dgevalue[j].ch1 = ch1;
                ch2 = dgevalue[i].ch2;
                dgevalue[i].ch2 = dgevalue[j].ch2;
                dgevalue[j].ch2 = ch2;
            }
        }
    }
}
void main()
{
    int i,j;
    MGraph G;
    char u;
    Dgevalue dgevalue;
    CreateUDG(G,dgevalue);
    cout<<"圖的鄰接矩陣為："<<endl;
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
            cout << G.arcs[i][j].adj<<" ";
        cout<<endl;
    }
    cout<<"=============普利姆算法===============\n";
    cout<<"請輸入起始點：";
    cin>>u;
    cout<<"構成最小代價生成樹的邊集為：\n";
    MiniSpanTree_PRIM(G,u);
    cout<<"============克魯斯科爾算法=============\n";
    cout<<"構成最小代價生成樹的邊集為：\n";
    MiniSpanTree_KRSL(G,dgevalue);
}