最小生成树算法

  1 package cn.Graph;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Scanner;
  5 
  6 /**
  7  * 使用kruskal算法生成图的MST
  8  * 其中：
  9  * 1.图的顶点存在了数组中
 10  * 2.图的带权边使用了EdgeNode对象，存在了数组中
 11  * 3.边按照权重进行排序利用最小堆进行排序，每次取出最小堆的根节点，便是权最小的边
 12  * 4.每次向MST中添加边肯定添加最小权的边，唯一条件便是不构成环
 13  * 5.上述不构成环是利用等价类<并查集>实现的
 14  * 6.并查集实现：树！每个顶点两个域：parent域&root域!find-union!重量规则！
 15  * @author cy
 16  *
 17  */
 18 public class Kruskal {
 19     boolean[] root;
 20     int[] parent;
 21     int currentSize=0;
 22     int maxSize=0;
 23     EdgeNode[] minHeap=new EdgeNode[20];
 24 
 25     /**
 26      * 初始化每个顶点为一个类
 27      * @param verNum 顶点的数量
 28      */
 29     public void initialize(int verNum){
 30         root=new boolean[verNum+1];
 31         parent=new int[verNum+1];
 32 
 33         for(int vertex=1;vertex<=verNum;vertex++){
 34             parent[vertex]=1;
 35             root[vertex]=true;
 36         }
 37     }
 38 
 39     /**
 40      * 寻找某个顶点元素所在的类
 41      * @param vertex 顶点
 42      * @return 返回的是顶点所在的类
 43      */
 44     public int find(int vertex){
 45         while(!root[vertex]){
 46             vertex=parent[vertex];
 47         }
 48         return vertex;
 49     }
 50 
 51     /**
 52      * 利用重量规则将两个根节点为i,j的类合并
 53      * @param i 根节点为i
 54      * @param j 根节点为j
 55      */
 56     public void union(int i,int j){
 57         if(parent[i]<parent[j]){
 58             parent[j]+=parent[i];
 59             root[i]=false;
 60             parent[i]=j;
 61         }else{
 62             parent[i]+=parent[j];
 63             root[j]=false;
 64             parent[j]=i;
 65         }
 66     }
 67 
 68     /**
 69      * 通过weight构建以EdgeNode为节点的最小堆
 70      * @param edgeNode为带权的边集
 71      */
 72     public void createMinHeap(EdgeNode[] edgeNode){
 73         currentSize=edgeNode.length;
 74         maxSize=minHeap.length;
 75         if(currentSize>=maxSize){
 76             maxSize*=2;
 77             minHeap=new EdgeNode[maxSize];
 78         }
 79         for(int i=0;i<currentSize;i++)
 80             minHeap[i+1]=edgeNode[i];
 81 
 82         int y,c;
 83         for(int i=currentSize/2;i>=1;i--){
 84             EdgeNode node=minHeap[i];
 85             y=node.weight;
 86             c=2*i;
 87             while(c<currentSize){
 88                 if(c<=currentSize && minHeap[c].weight>minHeap[c+1].weight)
 89                     c++;
 90                 if(minHeap[c].weight>=y)
 91                     break;
 92                 minHeap[c/2]=minHeap[c];
 93                 c=c*2;
 94             }
 95             minHeap[c/2]=node;
 96         }
 97     }
 98 
 99     /**
100      * 最小堆删除两种思路，一种和前面一样，就是一直跟踪放在根节点的那个最后一个节点最终插入的位置
101      * 另一种思路便是每一次完成完整的交换然后下一一层在进行同样处理
102      */
103     public EdgeNode deleteMinHeap(){
104         if(currentSize<1)
105             System.out.println("堆已经为空！无法执行删除");
106         EdgeNode node=minHeap[1];
107         minHeap[1]=minHeap[currentSize];
108         currentSize-=1;
109 
110         int c=2,j=1;
111         EdgeNode node1=minHeap[currentSize+1];
112         while(c<=currentSize){
113             if(c<currentSize && minHeap[c].weight>minHeap[c+1].weight)
114                 c++;
115             if(node1.weight<=minHeap[c].weight)
116                 break;
117             minHeap[j]=minHeap[c];
118             j=c;
119             c=c*2;
120         }
121         minHeap[j]=node1;
122         return node;
123     }
124 
125     /**
126      * 根据图的顶点集合带权边集生成MST
127      * @param verArray 顶点集
128      * @param edgeNode 带权边集
129      */
130     public void minSpanningTree(int[] verArray,EdgeNode[] edgeNode){
131         ArrayList<EdgeNode> nodeList=new ArrayList<EdgeNode>();
132 
133         initialize(verArray.length);
134         createMinHeap(edgeNode);
135 
136         for(int i=1;i<=currentSize;i++){
137             System.out.println(minHeap[i].u+" "+minHeap[i].v+" "+minHeap[i].weight);
138         }
139 
140         for(int i=0;i<edgeNode.length;i++){
141             EdgeNode node=deleteMinHeap();
142             int jRoot=find(node.u);
143             int kRoot=find(node.v);
144             if(jRoot!=kRoot){
145                 nodeList.add(node);
146                 union(jRoot,kRoot);
147             }
148         }
149         System.out.println("使用Kruskal算法得到图的最小生成树为：");
150         for(int i=0;i<nodeList.size();i++){
151             System.out.println(nodeList.get(i).u+" "+nodeList.get(i).v+" "+nodeList.get(i).weight);
152         }
153     }
154 
155     public static void main(String[] args) {
156         System.out.println("请输出图的顶点数和边数：");
157         @SuppressWarnings("resource")
158         Scanner scan=new Scanner(System.in);
159         int verNum=scan.nextInt();
160         int edgeNum=scan.nextInt();
161 
162         int[] verArray=new int[verNum];
163         System.out.println("请依次输入顶点：");
164         for(int i=0;i<verNum;i++){
165             int vertex=scan.nextInt();
166             verArray[i]=vertex;
167         }
168 
169         EdgeNode[] edgeNode=new EdgeNode[edgeNum];
170         System.out.println("请依次输入边的顶点和权重：");
171         for(int i=0;i<edgeNum;i++){
172             int u=scan.nextInt();
173             int v=scan.nextInt();
174             int weight=scan.nextInt();
175             EdgeNode node=new EdgeNode();
176             node.u=u;
177             node.v=v;
178             node.weight=weight;
179             edgeNode[i]=node;
180         }
181         Kruskal kruskal=new Kruskal();
182         kruskal.minSpanningTree(verArray,edgeNode);
183     }
184 }
185 class EdgeNode {
186     int weight;
187     int u,v;
188 }