// 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();
}
}
}