algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-06 00:54:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Enhance docs, add tests in Kruskal (#5967)

Browse Source
This commit is contained in:
Hardik Pawar
2024-10-24 11:11:55 +05:30
committed by GitHub
parent 578e5a73df
commit 0feb416188
3 changed files with 161 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/main/java/com/thealgorithms/datastructures/graphs/Kruskal.java
View File

@ -1,27 +1,34 @@
package com.thealgorithms.datastructures.graphs;
// Problem -> Connect all the edges with the minimum cost.
// Possible Solution -> Kruskal Algorithm (KA), KA finds the minimum-spanning-tree, which means, the
// group of edges with the minimum sum of their weights that connect the whole graph.
// The graph needs to be connected, because if there are nodes impossible to reach, there are no
// edges that could connect every node in the graph.
// KA is a Greedy Algorithm, because edges are analysed based on their weights, that is why a
// Priority Queue is used, to take first those less weighted.
// This implementations below has some changes compared to conventional ones, but they are explained
// all along the code.
import java.util.Comparator;
import java.util.HashSet;
import java.util.PriorityQueue;
/**
* The Kruskal class implements Kruskal's Algorithm to find the Minimum Spanning Tree (MST)
* of a connected, undirected graph. The algorithm constructs the MST by selecting edges
* with the least weight, ensuring no cycles are formed, and using union-find to track the
* connected components.
*
* <p><strong>Key Features:</strong></p>
* <ul>
* <li>The graph is represented using an adjacency list, where each node points to a set of edges.</li>
* <li>Each edge is processed in ascending order of weight using a priority queue.</li>
* <li>The algorithm stops when all nodes are connected or no more edges are available.</li>
* </ul>
*
* <p><strong>Time Complexity:</strong> O(E log V), where E is the number of edges and V is the number of vertices.</p>
*/
public class Kruskal {
// Complexity: O(E log V) time, where E is the number of edges in the graph and V is the number
// of vertices
private static class Edge {
/**
* Represents an edge in the graph with a source, destination, and weight.
*/
static class Edge {
private int from;
private int to;
private int weight;
int from;
int to;
int weight;
Edge(int from, int to, int weight) {
this.from = from;
@ -30,51 +37,30 @@ public class Kruskal {
}
}
private static void addEdge(HashSet<Edge>[] graph, int from, int to, int weight) {
/**
* Adds an edge to the graph.
*
* @param graph the adjacency list representing the graph
* @param from the source vertex of the edge
* @param to the destination vertex of the edge
* @param weight the weight of the edge
*/
static void addEdge(HashSet<Edge>[] graph, int from, int to, int weight) {
graph[from].add(new Edge(from, to, weight));
}
public static void main(String[] args) {
HashSet<Edge>[] graph = new HashSet[7];
for (int i = 0; i < graph.length; i++) {
graph[i] = new HashSet<>();
}
addEdge(graph, 0, 1, 2);
addEdge(graph, 0, 2, 3);
addEdge(graph, 0, 3, 3);
addEdge(graph, 1, 2, 4);
addEdge(graph, 2, 3, 5);
addEdge(graph, 1, 4, 3);
addEdge(graph, 2, 4, 1);
addEdge(graph, 3, 5, 7);
addEdge(graph, 4, 5, 8);
addEdge(graph, 5, 6, 9);
System.out.println("Initial Graph: ");
for (int i = 0; i < graph.length; i++) {
for (Edge edge : graph[i]) {
System.out.println(i + " <-- weight " + edge.weight + " --> " + edge.to);
}
}
Kruskal k = new Kruskal();
HashSet<Edge>[] solGraph = k.kruskal(graph);
System.out.println("\nMinimal Graph: ");
for (int i = 0; i < solGraph.length; i++) {
for (Edge edge : solGraph[i]) {
System.out.println(i + " <-- weight " + edge.weight + " --> " + edge.to);
}
}
}
/**
* Kruskal's algorithm to find the Minimum Spanning Tree (MST) of a graph.
*
* @param graph the adjacency list representing the input graph
* @return the adjacency list representing the MST
*/
public HashSet<Edge>[] kruskal(HashSet<Edge>[] graph) {
int nodes = graph.length;
int[] captain = new int[nodes];
// captain of i, stores the set with all the connected nodes to i
int[] captain = new int[nodes]; // Stores the "leader" of each node's connected component
HashSet<Integer>[] connectedGroups = new HashSet[nodes];
HashSet<Edge>[] minGraph = new HashSet[nodes];
PriorityQueue<Edge> edges = new PriorityQueue<>((Comparator.comparingInt(edge -> edge.weight)));
PriorityQueue<Edge> edges = new PriorityQueue<>(Comparator.comparingInt(edge -> edge.weight));
for (int i = 0; i < nodes; i++) {
minGraph[i] = new HashSet<>();
connectedGroups[i] = new HashSet<>();
@ -83,18 +69,21 @@ public class Kruskal {
edges.addAll(graph[i]);
}
int connectedElements = 0;
// as soon as two sets merge all the elements, the algorithm must stop
while (connectedElements != nodes && !edges.isEmpty()) {
Edge edge = edges.poll();
// This if avoids cycles
// Avoid forming cycles by checking if the nodes belong to different connected components
if (!connectedGroups[captain[edge.from]].contains(edge.to) && !connectedGroups[captain[edge.to]].contains(edge.from)) {
// merge sets of the captains of each point connected by the edge
// Merge the two sets of nodes connected by the edge
connectedGroups[captain[edge.from]].addAll(connectedGroups[captain[edge.to]]);
// update captains of the elements merged
// Update the captain for each merged node
connectedGroups[captain[edge.from]].forEach(i -> captain[i] = captain[edge.from]);
// add Edge to minimal graph
// Add the edge to the resulting MST graph
addEdge(minGraph, edge.from, edge.to, edge.weight);
// count how many elements have been merged
// Update the count of connected nodes
connectedElements = connectedGroups[captain[edge.from]].size();
}
}