克魯斯卡爾算法

基本介紹

克魯斯卡爾算法是求連通網的最小生成樹的另一種方法。與普里姆算法不同，它的時間復雜度為O（eloge）（e為網中的邊數），所以，適合於求邊稀疏的網的最小生成樹。基本思想:按照權值從小到大的順序選擇n-1條邊，並保證這n-1條邊不構成回路

案例

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

思路

這個案例還是最小生成樹的問題。

回路

終點：將所有頂點按照從小到大的順序排列好之后;某個頂點的終點就是"與它連通的最大頂點"。
上圖中，將E-F、C-D、D-E加入最小生成樹中后，這幾條邊的頂點的終點為:C>F,D>F,E>F,F>F,雖然第4步中C-E是最小的邊，但是C和E的終點都是F，將C-E加入最小生成樹中會構成回路。

代碼

public class KruskalDemo {
  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, MAX_VALUE, MAX_VALUE, MAX_VALUE,  16,  14},
            /*B*/ {  12,   0,  10, MAX_VALUE, MAX_VALUE,   7, MAX_VALUE},
            /*C*/ { MAX_VALUE,  10,   0,   3,   5,   6, MAX_VALUE},
            /*D*/ { MAX_VALUE, MAX_VALUE,   3,   0,   4, MAX_VALUE, MAX_VALUE},
            /*E*/ { MAX_VALUE, MAX_VALUE,   5,   4,   0,   2,   8},
            /*F*/ {  16,   7,   6, MAX_VALUE,   2,   0,   9},
            /*G*/ {  14, MAX_VALUE, MAX_VALUE, MAX_VALUE,   8,   9,   0}};
    KruskalDemo kruskal = new KruskalDemo(vertexs, matrix);
    kruskal.show();
    kruskal.kruskal();
  }

  private final char[] vertexs;  //存放頂點
  private int edgeNum; //邊的個數
  private final int[][] matrix; //鄰接矩陣
  private static final int MAX_VALUE = Integer.MAX_VALUE;

  /**
   * @param vertexs 存放頂點的數組
   * @param matrix 鄰接矩陣
   */
  public KruskalDemo(char[] vertexs, int[][] matrix) {
    int length = vertexs.length;
    this.vertexs = new char[length];
    //給vertexs賦值
    System.arraycopy(vertexs, 0, this.vertexs, 0, length);
    this.matrix = new int[length][length];
    //給matrix賦值
    for (int i = 0; i < length; i++) {
      System.arraycopy(matrix[i], 0, this.matrix[i], 0, length);
    }
    //統計邊的數量
    for (int i = 0; i < length; i++) {
      for (int j = i + 1; j < length; j++) {
        if (this.matrix[i][j] != MAX_VALUE) {
          edgeNum++;
        }
      }
    }
  }

  /**
   * 打印鄰接矩陣
   */
  public void show() {
    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();
    }
  }

  /**
   * 獲取圖中的所有邊
   * @return 存儲圖中邊的數組
   */
  private EData[] getEdges() {
    EData[] eData = new EData[edgeNum];
    int index = 0;
    for (int i = 0; i < vertexs.length; i++) {
      for (int j = i + 1; j < vertexs.length; j++) {
        if (matrix[i][j] != MAX_VALUE) {
          eData[index++] = new EData(vertexs[i],vertexs[j],matrix[i][j]);
        }
      }
    }
    return eData;
  }

  /**
   * 獲取頂點ch在數組中的下標
   * @param ch 頂點的值
   * @return 頂點在數組中的下標，找不到就返回-1
   */
  private int getPosition(char ch) {
    for (int i = 0; i < vertexs.length; i++) {
      if (vertexs[i] == ch) {
        return i;
      }
    }
    return -1;
  }

  /**
   * 冒泡排序
   * @param eData 待排序的數組
   */
  private void sort(EData[] eData) {
    for (int i = 0; i < eData.length - 1; i++) {
      for (int j = 0; j < eData.length - 1; j++) {
        if (eData[j].weight > eData[j + 1].weight) {
          EData temp = eData[j];
          eData[j] = eData[j + 1];
          eData[j + 1] = temp;
        }
      }
    }
  }

  /**
   * 獲取下標為i的頂點的終點
   * @param ends 存儲頂點對應的終點
   * @param i 傳入的頂點的下標
   * @return i在數組中對應的頂點的終點的下標
   */
  private int getEnd(int[] ends,int i) {
    while (ends[i] != 0) {
      i = ends[i];
    }
    return i;
  }

  /**
   * 克魯斯卡爾算法
   */
  public void kruskal() {
    int index = 0;  //結果數組的索引
    int[] ends = new int[edgeNum];  //存放各個頂點對應的終點
    EData[] results = new EData[edgeNum]; //存放結果
    EData[] edges = getEdges(); //所有的邊
    sort(edges);
    for (int i = 0; i < edgeNum; i++) {
      int index1 = getPosition(edges[i].start); //第i條邊的第一個頂點
      int index2 = getPosition(edges[i].end);   //第i條邊的第二個頂點
      int m = getEnd(ends, index1); //第i條邊的第一個頂點的終點的下標
      int n = getEnd(ends, index2); //第i條邊的第二個頂點的終點的下標
      if (m != n) {
        ends[m] = n;
        results[index++] = edges[i];
      }
    }
    for (int i = 0; i < index; i++) {
      System.out.println(results[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=" + start +
            ", end=" + end +
            ", weight=" + weight +
            '}';
  }
}