java 最小生成树算法

实现Java的最小生成树算法可以采用Prim算法或者Kruskal算法。在本文中，我将为小白开发者介绍如何使用Prim算法来实现最小生成树。

首先，让我们来了解一下Prim算法的流程。Prim算法是一种贪心算法，用于找到一个连通加权图的最小生成树。其基本思想是从图中的一个顶点开始，逐步选择与当前树连接的权重最小的边，直到生成一颗包含所有顶点的最小生成树。

以下是Prim算法的步骤：

步骤	描述
步骤1	选择一个顶点作为起始顶点，并将其加入最小生成树。
步骤2	从最小生成树中选择一条边，该边连接最小生成树中的顶点和不在最小生成树中的顶点，并且权重最小。
步骤3	将选择的边加入最小生成树，并将新加入的顶点标记为已访问。
步骤4	重复步骤2和步骤3，直到最小生成树包含所有顶点。

现在让我们来具体实现这些步骤。首先，我们需要定义一个图的类，用于表示图的顶点和边，以及实现Prim算法。以下是一个简单的图的类的示例：

import java.util.ArrayList;
import java.util.List;

class Graph {
    private int vertices;
    private List<List<Edge>> adjacencyList;

    public Graph(int vertices) {
        this.vertices = vertices;
        this.adjacencyList = new ArrayList<>(vertices);
        for (int i = 0; i < vertices; i++) {
            this.adjacencyList.add(new ArrayList<>());
        }
    }

    public void addEdge(int source, int destination, int weight) {
        Edge edge = new Edge(source, destination, weight);
        this.adjacencyList.get(source).add(edge);
        this.adjacencyList.get(destination).add(edge);
    }

    public void primMST() {
        boolean[] visited = new boolean[vertices];
        int[] parent = new int[vertices];
        int[] key = new int[vertices];

        for (int i = 0; i < vertices; i++) {
            key[i] = Integer.MAX_VALUE;
        }

        key[0] = 0;
        parent[0] = -1;

        for (int i = 0; i < vertices - 1; i++) {
            int minKeyIndex = getMinKeyIndex(key, visited);
            visited[minKeyIndex] = true;

            for (Edge edge : adjacencyList.get(minKeyIndex)) {
                int adjacentVertex = edge.getAdjacentVertex(minKeyIndex);
                int weight = edge.getWeight();

                if (!visited[adjacentVertex] && weight < key[adjacentVertex]) {
                    parent[adjacentVertex] = minKeyIndex;
                    key[adjacentVertex] = weight;
                }
            }
        }

        printMST(parent);
    }

    private int getMinKeyIndex(int[] key, boolean[] visited) {
        int minKey = Integer.MAX_VALUE;
        int minKeyIndex = -1;

        for (int i = 0; i < vertices; i++) {
            if (!visited[i] && key[i] < minKey) {
                minKey = key[i];
                minKeyIndex = i;
            }
        }

        return minKeyIndex;
    }

    private void printMST(int[] parent) {
        System.out.println("Edge \tWeight");
        for (int i = 1; i < vertices; i++) {
            System.out.println(parent[i] + " - " + i + "\t" + adjacencyList.get(i).get(parent[i]).getWeight());
        }
    }
}

class Edge {
    private int source;
    private int destination;
    private int weight;

    public Edge(int source, int destination, int weight) {
        this.source = source;
        this.destination = destination;
        this.weight = weight;
    }

    public int getAdjacentVertex(int vertex) {
        if (vertex == source) {
            return destination;
        } else {
            return source;
        }
    }

    public int getWeight() {
        return weight;
    }
}

在这个示例中，我们定义了一个Graph类，其中包含了添加边以及实现Prim算法的方法。首先，我们定义了一个邻接表来表示图的顶点和边。然后，我们使用addEdge方法添加图的边