最小生成树的prime和kruskal算法

 

// test_project.cpp : 定义控制台应用程序的入口点。

//贪心算法

//最小生成树的prime的算法

#include"stdafx.h"

#include<iostream>

#define maxint 99999;

usingnamespace std;

//int maxint=mar_maxint;

 

template<typename Type>

void Prim(int n,Type**c);

 

void main()

{

   double**c=newdouble*[7];

   for(int i=0;i<7;i++)

   {

     c[i]=newdouble[7];

   }

 

   for(int i=0;i<7;i++)

     for(int j=0;j<7;j++)

        c[i][j]=maxint;

   c[1][2]=6;c[1][3]=1;c[1][4]=5;

   c[2][1]=6;c[2][3]=5;c[2][5]=3;

   c[3][1]=1;c[3][2]=5;c[3][4]=5;c[3][5]=6;c[3][6]=4;

   c[4][1]=5;c[4][3]=5;c[4][6]=2;

   c[5][2]=3;c[5][3]=6;c[5][6]=6;

   c[6][3]=4;c[6][4]=2;c[6][5]=6;

 

   Prim(6,c);

 

}

 

template<typename Type>

void Prim(int n,Type**c)

{

  

   Type lowcost[7];

   int closest[7];

   bool s[7];

   s[1]=true;

   for(int i=2;i<=n;i++)

   {

     lowcost[i]=c[1][i];

     closest[i]=1;

     s[i]=false;

   }

   for(int i=1;i<n;i++)

   {

     Type min=maxint;

     int j=1;

     for(int k=2;k<=n;k++)

        if((lowcost[k]<min)&&(!s[k]))

        {

          min=lowcost[k];

          j=k;

        }

     cout<<j<<" "<<closest[j]<<endl;

     s[j]=true;

     for(int k=2;k<=n;k++)

        if((c[j][k]<lowcost[k])&&(!s[k]))

        {

          lowcost[k]=c[j][k];

          closest[k]=j;

        }

   }

}

// test_project.cpp : 定义控制台应用程序的入口点。

//贪心算法

//最小生成树的kruskal的算法

#include"stdafx.h"

#include<iostream>

#include<algorithm>

#include<vector>

usingnamespace std;

//int maxint=mar_maxint;

class BinaryTree;

class EdgeNode//边的数据结构

{

private:

   int u,v;//边所在的顶点

   double weight;//边的权值

   friend ostream&operator<<(ostream&os,const EdgeNode&E);

   friendvoid Kruskal(vector<EdgeNode>&E,vector<BinaryTree>&B,vector<EdgeNode>&N);

   //friend bool maxless(const EdgeNode&E1,const EdgeNode&E2);

public:

   EdgeNode(int u1=0,int v1=0,double weight1=0):u(u1),v(v1),weight(weight1){}

   booloperator<(const EdgeNode&E)const

   {

     return weight>E.weight;

   }

};

 

class BinaryTree//树的数据结构，开始有n个节点，就有n棵树，随着边的加入，数不断组合

{

public:

   int root;//存储每棵树的根，以改树中最小的结点为根

   vector<int>S;//树的所有结点，包含根结点

   BinaryTree(int r1)

   {

     root=r1;

     S.push_back(r1);

   }

};

 

 

//bool maxless(const EdgeNode&E1,const EdgeNode&E2)

//{

   //return E1.weight>E2.weight;

//}

 

ostream&operator<<(ostream&os,const EdgeNode&E);

int D_Find(vector<BinaryTree>B,int u,int&index);

void D_Union(vector<BinaryTree>&B,int index1,int index2);

void Kruskal(vector<EdgeNode>&E,vector<BinaryTree>&B,vector<EdgeNode>&N);

 

void main()

{

   vector<EdgeNode>E;

   vector<BinaryTree>B;

   vector<EdgeNode>N;

   E.push_back(EdgeNode(1,4,5));

   E.push_back(EdgeNode(1,3,1));

   E.push_back(EdgeNode(1,2,6));

   E.push_back(EdgeNode(2,3,5));

   E.push_back(EdgeNode(2,5,3));

   E.push_back(EdgeNode(3,4,5));

   E.push_back(EdgeNode(3,6,4));

   E.push_back(EdgeNode(3,5,6));

   E.push_back(EdgeNode(4,6,2));

   E.push_back(EdgeNode(5,6,6));

   sort(E.begin(),E.end());

 

   for(int i=1;i<=6;i++)

   B.push_back(BinaryTree(i));

   Kruskal(E,B,N);

   for(int i=0;i<N.size();i++)

     cout<<N[i];

  

 

}

 

 

 

ostream&operator<<(ostream&os,const EdgeNode&E)

{

   os<<"("<<E.u<<","<<E.v<<")"<<endl;

   return os;

}

 

//找出结点u在树的向量集中的哪个数上，index存储数的索引

int D_Find(vector<BinaryTree>B,int u,int&index)

{

   //vector<BianryTree>::iterator it1;

   for(int i=0;i<B.size();i++)

   {

     for(int j=0;j<B[i].S.size();j++)

     {

        if(B[i].S[j]==u)//找到了u

        {

          index=i;//包含u的树，在B中的索引位置

          return B[i].root;

        }

       

     }

 

   }

   return -1;

}

 

//合并数集中，在index1，index2处的数

void D_Union(vector<BinaryTree>&B,int index1,int index2)

{

   if(B[index1].root<B[index2].root)

   {

     for(int i=0;i<B[index2].S.size();i++)

     {

        B[index1].S.push_back(B[index2].S[i]);//将index2处得合并到index1处

        //

     }

     B.erase(B.begin()+index2);

     //int temp1=0;

   }

   else

   {

     B[index1].root=B[index2].root;

     for(int i=0;i<B[index2].S.size();i++)

     {

        B[index1].S.push_back(B[index2].S[i]);//将index2处得合并到index1处

     }

     B.erase(B.begin()+index2);

 

 

   }

}

/******************************************************************

*函数名称：Kruskal算法

*函数参数:存储边的集，存储节点的集，存储被选中的边

*******************************************************************/

 

void Kruskal(vector<EdgeNode>&E,vector<BinaryTree>&B,vector<EdgeNode>&N)

{

   int d1=0,d2=0,index1=0,index2=0,u=0,v=0;

   while((B.size()>1)||(!E.empty()))//当没有合并成一棵树时，循环继续

   {

      u=E.back().u;

      v=E.back().v;

     d1=D_Find(B,u,index1);

     d2=D_Find(B,v,index2);

     if(d1==d2)

     {

        E.pop_back();

     }

     else

     {

        D_Union(B,index1,index2);

        int temp=0;

        N.push_back(E.back());

        E.pop_back();

     }

   }

}