最小生成树

prim算法

 

1. #include<iostream>
2. #include<stdlib.h>
3. using namespace std;
5. #define OK 1
6. #define OVERFLOW -2
7. #define MAX 1000
9. typedef int Status;
10. typedef char VertexType;
11. typedef int* Inpoint;
12. typedef int VRType;
13. typedef enum{DG,DN,UDG,UDM} GraphKind;
15. typedef struct {
16.         VertexType *vexs;
17.         int **arcs;
18.         int vexnum,arcnum;
19.         GraphKind kind;
20.         }MGraph;
21.         
22. int LocateVex(MGraph G,VertexType v){
23.     for(int i=0;i<G.vexnum;i++)
24.         if(v==G.vexs[i]) return i;
25.     return G.vexnum;}
27. Status  CreateUDM(MGraph &G){
28.         G.kind=UDM;
29.         cin>>G.vexnum>>G.arcnum;
30.         G.vexs=new VertexType[G.vexnum];
31.     G.arcs=new Inpoint[G.vexnum];
32.     if(!G.vexs||!G.arcs)    exit(OVERFLOW);
33.     int i,j,k;
34.     for(i=0;i<G.vexnum;i++){
35.         if(!(G.arcs[i]=new int[G.vexnum]))  exit(OVERFLOW);
36.         for(j=0;j<G.vexnum;j++)
37.             if(i!=j) G.arcs[i][j]=MAX;
38.             else     G.arcs[i][j]=0;}
39.     VertexType v1,v2;
40.         for(i=0;i<G.vexnum;i++)
41.                 cin>>G.vexs[i];
42.         for(k=0;k<G.arcnum;k++){
43.                 do{
44.                       cin>>v1>>v2;
45.                       i=LocateVex(G,v1);
46.                       j=LocateVex(G,v2);
47.                       cin>>G.arcs[i][j];
48.                       G.arcs[j][i]=G.arcs[i][j];
49.                       }while(i==G.vexnum||j==G.vexnum);
50.         }
51.     return OK;
52. }
54. void MiniSpanTree(MGraph G){
55.    typedef struct{
56.     VertexType adjvex;
57.     VRType lowcost;}Node,*cclosedge;
59.    cclosedge closedge;
60.    if(!(closedge=new Node[G.vexnum])) exit(OVERFLOW);
61.    int i,j,k,min;
62.    for(i=0;i<G.vexnum;i++) {                  
63.        closedge[i].lowcost=G.arcs[0][i];
64.        closedge[i].adjvex=G.vexs[0];} 
65.     for(i=1;i<G.vexnum;i++){ 
66.             min=MAX;
67.         j=1;
68.         while(j<G.vexnum) {
69.           if(closedge[j].lowcost&&closedge[j].lowcost<min){
70.             min=closedge[j].lowcost;
71.             k=j;}
72.           j++;}
73.         cout<<closedge[k].adjvex<<"/t"<<G.vexs[k]<<"/t"<<min<<endl;;
74.         closedge[k].lowcost=0;
75.         for(j=1;j<G.vexnum;j++)                  
76.            if(G.arcs[k][j]<closedge[j].lowcost) {
77.               closedge[j].lowcost=G.arcs[k][j];
78.               closedge[j].adjvex=G.vexs[k];}
79.         }
80. }
82. int main(){
83.     MGraph G;
84.     CreateUDM(G);
85.     MiniSpanTree(G);
86.         return 0;}
87. 输入：
88. 6 10
89. a b c d e f
90. a b 6
91. a d 5
92. a c 1
93. b c 5
94. c d 5
95. b e 3
96. c e 6
97. c f 4
98. d f 2
99. e f 6
100. 输出：
101. a       c       1
102. c       f       4
103. f       d       2
104. c       b       5
105. b       e       3
106. 请按任意键继续. . .

kruskal算法

 

1. #include<iostream>
2. #include<stdlib.h>
3. using namespace std;
4. #define MAX 1000
5. #define OVERFLOW -2
6. typedef char VertexType;
7. typedef struct{
8.        VertexType v1,v2;
9.        int cost;}EdgeType,*PEdge;       
10. typedef struct{
11.         VertexType *vexs;     //顶点数组
12.         PEdge edges;         //边数组
13.         int vexnum,arcnum;}Graph;
15. int Cmp(const void *a,const void *b){
16.     return (*(PEdge)a).cost-(*(PEdge)b).cost;}
18. void Create(Graph &G){
19.      cin>>G.vexnum>>G.arcnum;
20.      if(!(G.vexs = new VertexType[G.vexnum])||!(G.edges = new EdgeType[G.arcnum])) 
21.           exit(OVERFLOW);
22.      int i,j,k;
23.      for(i=0;i<G.vexnum;i++)
24.           cin>>G.vexs[i];
25.      for(i=0;i<G.arcnum;i++)
26.           cin>>G.edges[i].v1>>G.edges[i].v2>>G.edges[i].cost;
27.      qsort(G.edges,G.arcnum,sizeof(EdgeType),Cmp); 
28.       //对边数组按权值从小到大排序
29. }
31. int LocateVex(Graph G,VertexType v){ 
32.     for(int i=0;i<G.vexnum;i++) 
33.         if(v==G.vexs[i]) return i; 
34.     return G.vexnum;} 
36. int Find(Graph G,int *tree,VertexType v){//返回V的根节点
37.     int t=LocateVex(G,v);
38.     while(tree[t]>=0)
39.          t=tree[t];
40.     return t;}    
42. void Kruskal(Graph &G){
43.      int *tree;
44.      if(!(tree=new int[G.vexnum])) exit(OVERFLOW);
45.      int i,j=1,V1,V2;
46.      for(i=0;i<G.vexnum;i++) tree[i]=-1;
47.      i=0;
48.      while(j<G.vexnum){
49.          V1=Find(G,tree,G.edges[i].v1);
50.          V2=Find(G,tree,G.edges[i].v2);
51.          if(V1!=V2){
52.                     tree[V2]=V1;   //V1作为V2的根节点
53.                     j++;
54.                     cout<<G.edges[i].v1<<"/t"<<G.edges[i].v2<<"/t"<<G.edges[i].cost<<endl;}
55.          i++;}
56.      }
57. int main(){
58.     Graph G;
59.     Create(G);
60.     Kruskal(G);
61.     return 0;}
62. 输入：
63. 6 10
64. a b c d e f
65. a b 6
66. a d 5
67. a c 1
68. b c 5
69. c d 5
70. b e 3
71. c e 6
72. c f 4
73. d f 2
74. e f 6
75. 输出：
76. a       c       1
77. d       f       2
78. b       e       3
79. c       f       4
80. b       c       5
81. 请按任意键继续. . .
82.