常用十大算法（七）— 克魯斯卡爾算法

常用十大算法（七）— 克魯斯卡爾算法

博客說明

文章所涉及的資料來自互聯網整理和個人總結，意在於個人學習和經驗匯總，如有什么地方侵權，請聯系本人刪除，謝謝！

介紹

• 克魯斯卡爾(Kruskal)算法，是用來求加權連通圖的最小生成樹的算法。

最小生成樹

• 最小生成樹(Minimum Cost Spanning Tree)，簡稱MST。
• 給定一個帶權的無向連通圖,如何選取一棵生成樹,使樹上所有邊上權的總和為最小,這叫最小生成樹
• N個頂點，一定有N-1條邊
• 包含全部頂點
• N-1條邊都在圖中
• 求最小生成樹的算法主要是普里姆算法和克魯斯卡爾算法

修路問題

• 有北京有新增7個站點(A, B, C, D, E, F, G) ，現在需要修路把7個站點連通
• 各個站點的距離用邊線表示(權) ，比如 A – B 距離 12公里
• 問：如何修路保證各個站點都能連通，並且總的修建公路總里程最短?

思路

• 基本思想：按照權值從小到大的順序選擇n-1條邊，並保證這n-1條邊不構成回路
• 具體做法：首先構造一個只含n個頂點的森林，然后依權值從小到大從連通網中選擇邊加入到森林中，並使森林中不產生回路，直至森林變成一棵樹為止

問題一

排序

問題二

判斷回路

代碼實現

package com.atguigu.kruskal;

import java.util.Arrays;

public class KruskalCase {

	private int edgeNum; //邊的個數
	private char[] vertexs; //頂點數組
	private int[][] matrix; //鄰接矩陣
	//表示不聯通
	private static final int INF = Integer.MAX_VALUE;
	
	public static void main(String[] args) {
		char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
	  int matrix[][] = {
	      /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
	/*A*/ {   0,  12, INF, INF, INF,  16,  14},
	/*B*/ {  12,   0,  10, INF, INF,   7, INF},
	/*C*/ { INF,  10,   0,   3,   5,   6, INF},
	/*D*/ { INF, INF,   3,   0,   4, INF, INF},
	/*E*/ { INF, INF,   5,   4,   0,   2,   8},
	/*F*/ {  16,   7,   6, INF,   2,   0,   9},
	/*G*/ {  14, INF, INF, INF,   8,   9,   0}
    }; 
	  KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
	  kruskalCase.print();
	  kruskalCase.kruskal(); 
	}
	
	//構造器
	public KruskalCase(char[] vertexs, int[][] matrix) {
		int vlen = vertexs.length;
		
		//復制拷貝
		this.vertexs = new char[vlen];
		for(int i = 0; i < vertexs.length; i++) {
			this.vertexs[i] = vertexs[i];
		}
		
		//初始化表
		this.matrix = new int[vlen][vlen];
		for(int i = 0; i < vlen; i++) {
			for(int j= 0; j < vlen; j++) {
				this.matrix[i][j] = matrix[i][j];
			}
		}

		for(int i =0; i < vlen; i++) {
			for(int j = i+1; j < vlen; j++) {
				if(this.matrix[i][j] != INF) {
					edgeNum++;
				}
			}
		}
	}
  
  //克魯斯卡爾算法
	public void kruskal() {
		int index = 0; 
		int[] ends = new int[edgeNum]; 
		EData[] rets = new EData[edgeNum];
		
		EData[] edges = getEdges();
		System.out.println("圖的邊的集合=" + Arrays.toString(edges) + "共"+ edges.length); //12    
		
		//排序
		sortEdges(edges);
		
    //遍歷數組
		for(int i=0; i < edgeNum; i++) {
			int p1 = getPosition(edges[i].start);
			int p2 = getPosition(edges[i].end);
			int m = getEnd(ends, p1);
			int n = getEnd(ends, p2);
			if(m != n) {
				ends[m] = n;
				rets[index++] = edges[i];
			}
		}
		System.out.println("×îСÉú³ÉÊ÷Ϊ");
		for(int i = 0; i < index; i++) {
			System.out.println(rets[i]);
		}
	}
	

	public void print() {
		System.out.println("鄰接矩陣: \n");
		for(int i = 0; i < vertexs.length; i++) {
			for(int j=0; j < vertexs.length; j++) {
				System.out.printf("%12d", matrix[i][j]);
			}
			System.out.println();
		}
	}

	//對邊排序
	private void sortEdges(EData[] edges) {
		for(int i = 0; i < edges.length - 1; i++) {
			for(int j = 0; j < edges.length - 1 - i; j++) {
				if(edges[j].weight > edges[j+1].weight) {//½»»»
					EData tmp = edges[j];
					edges[j] = edges[j+1];
					edges[j+1] = tmp;
				}
			}
 		}
	}
	
  //頂點的值
	private int getPosition(char ch) {
		for(int i = 0; i < vertexs.length; i++) {
			if(vertexs[i] == ch) {
				return i;
			}
		}
		return -1;
	}
  
	//獲取圖中的邊
	private EData[] getEdges() {
		int index = 0;
		EData[] edges = new EData[edgeNum];
		for(int i = 0; i < vertexs.length; i++) {
			for(int j=i+1; j <vertexs.length; j++) {
				if(matrix[i][j] != INF) {
					edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
				}
			}
		}
		return edges;
	}
	
  //獲取終點
	private int getEnd(int[] ends, int i) { ]
		while(ends[i] != 0) {
			i = ends[i];
		}
		return i;
	}
 
}

//邊
class EData {
	char start; //起點
	char end; //終點
	int weight; //權值
	//構造器
	public EData(char start, char end, int weight) {
		this.start = start;
		this.end = end;
		this.weight = weight;
	}

	@Override
	public String toString() {
		return "EData [<" + start + ", " + end + ">= " + weight + "]";
	}
}

感謝

尚硅谷

以及勤勞的自己，個人博客，GitHub