最小生成树算法prim and kruskal

一.最小生成树定义：

 从不同顶点出发或搜索次序不同，可得到不同的生成树

 生成树的权：对连通网络来说，边附上权，生成树也带权，我们把生成树各边的权值总和称为生成树的权

 最小代价生成树：在一个连通网的所有生成树中， 各边的代价之和最小的那棵生成树称为该连通网的最小代价生成树（Minimum Cost Spanning Tree），简称为最小生成树(MST)。

二.最小生成树prim算法

算法思路：step1:假设N=(V,{E})是连通网，TE是N上最小生成树中边的集合。算法从U={u₀}(u₀属于V),TE={}开始。

step2:在所有的u属于U，v属于V-U的边（u，v)属于E中找一条代价最小的边（u₀,v₀)并入集合TE。同时v₀并入U。

step3:更新边（u，v)的最小值。

step4:c重复step2 and step3直到U=V。

code:

 //MiniSpanTree_Prim.cpp
 //This function is to create MiniSpanTree_Prim with Prim Algorithm
 # include <iostream.h>
 # include <malloc.h>
 # include <conio.h>

 # define INFINITY
 # define MAX_VERTEX_NUM
 # define OK
 typedef enum{DG,DN,UDG,UDN} GraphKind;
 typedef int EType;
 typedef int InfoType;
 typedef int VertexType;
 typedef int VRType;
 typedef int lowcost;

 typedef struct        //define Closedege structure
 {   VertexType adjvex;
     VRType    lowcost;
 }Closedge;

 typedef struct ArcCell    //define MGraph structure
 {  EType adj;
    InfoType *info;
 }ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

 typedef struct
 {  VertexType vexs[MAX_VERTEX_NUM];
    AdjMatrix  arcs;
    int vexnum,arcnum;
    GraphKind kind;
 }MGraph;

 int CreatUDN(MGraph &G)        //CreatUDN() sub-function
 {  int IncInfo,i=,j=,k,v1,v2,w;
    cout<<endl<<"Please input the number of G.vexnum (eg,G.vexnum=4) : ";
    cin>>G.vexnum;                  //input the number of vex
    cout<<"Please input the number of G.arcnum (eg,G.arcnum=4) : ";
    cin>>G.arcnum;        //input the number of arc
    for(i=;i<G.vexnum;++i)
      for(j=i;j<G.vexnum;++j)
       {     G.arcs[i][j].adj=G.arcs[j][i].adj=INFINITY;    //initial weigh
      G.arcs[i][j].info=G.arcs[j][i].info=NULL;
       }
    cout<<"Please input IncInfo (0 for none)                   : ";
    cin>>IncInfo;        //if need information, input non-zero
    cout<<"Plese input arc(V1-->V2), For example: (V1=1,V2=3),(V1=2,V2=4)..."<<endl;
    for(k=;k<G.arcnum;++k)    //input arc(v1,v2)
    {   cout<<endl<<"Please input the "<<k+<<"th arc's v1 (0<v1<G.vexnum) : ";
        cin>>v1;
        cout<<"Please input the "<<k+<<"th arc's v2 (0<v2<G.vexnum) : ";
        cin>>v2;
        cout<<"Please input the "<<k+<<"th arc's weight             : ";
        cin>>w;
        i=v1;
        j=v2;
        while(i<||i>G.vexnum||j<||j>G.vexnum)    //if (v1,v2) illegal
        {   cout<<"Please input the "<<k+<<"th arc's v1 (0<v1<G.vexnum) : ";
        cin>>v1;
        cout<<"Please input the "<<k+<<"th arc's v2 (0<v1<G.vexnum) : ";
        cin>>v2;
        cout<<"Please input the "<<k+<<"th arc's weight             : ";
        cin>>w;
        i=v1;
        j=v2;
        } //while end
        i--;
        j--;
    G.arcs[i][j].adj=G.arcs[j][i].adj=w;        //
    cout<<"G.arcs["<<i+<<"]["<<j+<<"].adj=";
    cout<<"G.arcs["<<j+<<"]["<<i+<<"].adj="<<G.arcs[j][i].adj<<endl;
    if(IncInfo)
      {   cout<<"Please input the "<<k+<<"th arc's Info : ";
      cin>>*G.arcs[i][j].info;        //input information
      }
    } //for end
    return (OK);
 } //CreatUDN() end

 int Minimum(Closedge *closedge,int Vexnum)    //Minimum() sub-function
 {   int min=,j;                        //return min (closedge[min].lowcost)
     if(closedge[min].lowcost==)
       min++;                //closedge[min].lowcost!=0
     for(j=;j<Vexnum;++j)
       if(closedge[j].lowcost<closedge[min].lowcost
           &&closedge[j].lowcost>)
     min=j;
     return (min);
 } //Minimim() end

 int LocatedVex(MGraph G,VertexType u)    //LocatedVex() sub-fuction
 {  return (u);
 }

 void MiniSpanTree_Prim(MGraph G,VertexType u)    //MiniSpanTree_Prim() sub-function
 {  int k,j,i,Vexnum=G.vexnum;
    k=LocatedVex(G,u);
    Closedge closedge[MAX_VERTEX_NUM];
    for(j=;j<G.vexnum;++j)    //initial closedge[]
      if(j!=k)
      {    closedge[j].adjvex=u;      // (u,j)
     closedge[j].lowcost=G.arcs[k][j].adj;
      }
    closedge[k].lowcost=;    //U include k
    for(i=;i<G.vexnum;++i)
    {  k=Minimum(closedge,Vexnum);    //select k=min(closedge[vi].lowcost)
       cout<<endl<<"("<<closedge[k].adjvex+<<","<<k+<<")";
       cout<<"="<<G.arcs[closedge[k].adjvex][k].adj;
       closedge[k].lowcost=;    //U include k
       for(j=;j<G.vexnum;++j)   //renew closedge[k]
     if(G.arcs[k][j].adj<closedge[j].lowcost)
        {  closedge[j].adjvex=k;
           closedge[j].lowcost=G.arcs[k][j].adj;
        } //if end
    } //for end
 } //Minimun() end

 void main()              //main() function
 {   MGraph G;
     VertexType u=;
     cout<<endl<<endl<<"MiniSpanTree_Prim.cpp";
     cout<<endl<<"====================="<<endl;
     CreatUDN(G);        //call CreatUDN(G) function
     cout<<endl<<"The MiniSpanTree_Prim is created as follow order:";
     MiniSpanTree_Prim(G,u);    //call MiniSpanTree_Prim() function
     cout<<endl<<endl<<"...OK!...";
     getch();
 } //main() end

三.最小生成树kruskal算法

算法思路：step1:假设联通网N=(V,{E})，则领最小生成树的初始状态为只有n个定点而无边的非联通图T=(V,{}),同中每个定点自成一个连通分量。

step2:在E中选择代价最小的边，若改边的定点落在T中不同的连通分量上，则将此边加入到T中，否则舍弃此边而选择下一条代价最小的边。

　　　　　step3:依次类推知道T中所有定点都在同一连通分量上。

时间复杂度：O(eloge)

#include<iostream>
#include<vector>
#include<map>
using namespace std;
class edge
{
public:
    edge(char a,char b,int wight):ma(a),mb(b),mwight(wight){}
    edge(const edge &other)
    {
        ma = other.ma;
        mb = other.mb;
        mwight = other.mwight;
    }
    edge & operator=(const edge & other)
    {
        ma = other.ma;
        mb = other.mb;
        mwight = other.mwight;
        return *this;
    }
    char getma()
    {
        return ma;
    }
    char getmb()
    {
        return mb;
    }
private:
    char ma;
    char mb;
    int mwight;
};

void  kruskal(vector<edge> & edges,map<char,int> & vertexs,vector<edge> &myedge)
{

    vector<edge>::iterator begin = edges.begin();
    for (;begin != edges.end(); begin++)
    {
        int vera = vertexs[begin->getma()];
        int verb = vertexs[begin->getmb()];
        if ( vera != verb)
        {
            myedge.push_back(*begin);
            map<char,int>::iterator item = vertexs.begin();
            for(;item != vertexs.end();item++)
            {
                if (item->second == vera)
                {
                    item->second = verb;
                }
            }
        }
    }
}

void main()
{
    char ch;
    int i;
    edge edges[] = {
        edge('a','c',),
        edge('d','f',),
        edge('b','e',),
        edge('c','f',),
        edge('a','d',),
        edge('c','d',),
        edge('c','b',),
        edge('a','b',),
        edge('c','e',),
        edge('c','f',)
    };
    map<char,int> vertex;
    vector<edge> myedges(edges,edges+sizeof(edges)/sizeof(edge)),result;
    for( ch='a', i =;i<;ch++,i++)
    {
        vertex.insert(std::pair<char,int>(ch,i));
    }
    kruskal(myedges,vertex,result);
    for (vector<edge>::iterator start = result.begin(); start != result.end(); start++)
    {
        cout<<start->getma()<<"--"<<start->getmb()<<" "<<endl;
    }
}