Open In App

Boruvka's Algorithm using Python

Last Updated : 26 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Boruvka's algorithm is a greedy algorithm for finding the Minimum Spanning Tree (MST) in a connected, weighted, and undirected graph. It was one of the first algorithms for this problem and is named after Otakar Borůvka, who introduced it in 1926. This algorithm works by repeatedly finding the shortest edge that connects each component of the graph to a different component until all components are merged into a single tree.

Concepts Related to the Topic

Minimum Spanning Tree (MST):

An MST of a graph is a subset of its edges that connects all vertices, without any cycles, and with the minimum possible total edge weight.

Graph Terminology:

  • Vertex (Node): A point in the graph.
  • Edge: A connection between two vertices, which may have a weight (cost).
  • Component: A subgraph in which any two vertices are connected directly or indirectly.

Disjoint Set Union (DSU) / Union-Find:

  • Data Structure: Manages disjoint sets, supporting Find and Union operations efficiently.
  • Path Compression: Flattens the structure during Find operations for efficiency.
  • Union by Rank: Keeps trees shallow during Union operations for efficiency.

Greedy Algorithms

  • Greedy Choice Property: Build solution piece by piece, choosing the next piece with the most immediate benefit.
  • Local Optimality: Each step is locally optimal, leading to a global solution.

Boruvka's Algorithm Steps

  1. Initialize the MST as an empty set.
  2. Treat each vertex as a separate component.
  3. Find the cheapest edge from each component to another component.
  4. Add these edges to the MST and merge the components.
  5. Repeat until only one component (the MST) remains.

Let's consider a graph with the following vertices and edges:

file
Graph

Certainly! Here are the edges listed with their respective weights of this graph:

  • Edge (0, 1): Weight 10
  • Edge (0, 2): Weight 6
  • Edge (0, 3): Weight 5
  • Edge (1, 3): Weight 15
  • Edge (2, 3): Weight 4

Implementation:

C++ 
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class Edge {
public:
    int src, dest, weight;
};

class Graph {
public:
    int V; // Number of vertices
    vector<Edge> edges; // Vector to store graph edges

    Graph(int vertices) : V(vertices) {}

    // Function to add an edge to the graph
    void add_edge(int u, int v, int w) {
        Edge edge;
        edge.src = u;
        edge.dest = v;
        edge.weight = w;
        edges.push_back(edge);
    }

    // Find function to find the parent of a node
    int find(vector<int>& parent, int i) {
        if (parent[i] == i)
            return i;
        return find(parent, parent[i]);
    }

    // Union function to perform union of two subsets
    void union_sets(vector<int>& parent, vector<int>& rank, int x, int y) {
        int root_x = find(parent, x);
        int root_y = find(parent, y);

        if (rank[root_x] < rank[root_y])
            parent[root_x] = root_y;
        else if (rank[root_x] > rank[root_y])
            parent[root_y] = root_x;
        else {
            parent[root_y] = root_x;
            rank[root_x]++;
        }
    }

    // Boruvka's algorithm to find Minimum Spanning Tree
    void boruvka_mst() {
        vector<int> parent(V);
        vector<int> rank(V, 0);
        vector<Edge> mst_edges;

        int mst_weight = 0;
        int num_of_trees = V;

        // Initialize each vertex as its own parent
        for (int node = 0; node < V; ++node)
            parent[node] = node;

        // Iterate until all vertices are in one component
        while (num_of_trees > 1) {
            vector<Edge> cheapest(V, { -1, -1, -1 });

            // Traverse through all edges and update cheapest of every component
            for (Edge& edge : edges) {
                int set1 = find(parent, edge.src);
                int set2 = find(parent, edge.dest);

                if (set1 != set2) {
                    if (cheapest[set1].weight == -1 || edge.weight < cheapest[set1].weight)
                        cheapest[set1] = edge;

                    if (cheapest[set2].weight == -1 || edge.weight < cheapest[set2].weight)
                        cheapest[set2] = edge;
                }
            }

            // Add the cheapest edges to the MST
            for (int node = 0; node < V; ++node) {
                if (cheapest[node].weight != -1) {
                    Edge edge = cheapest[node];
                    int set1 = find(parent, edge.src);
                    int set2 = find(parent, edge.dest);

                    if (set1 != set2) {
                        mst_weight += edge.weight;
                        union_sets(parent, rank, set1, set2);
                        mst_edges.push_back(edge);
                        num_of_trees--;
                    }
                }
            }
        }

        // Print the weight of MST and edges in MST
        cout << "Weight of MST is " << mst_weight << endl;
        cout << "Edges in MST are:" << endl;
        for (Edge& edge : mst_edges) {
            cout << edge.src << " -- " << edge.dest << " == " << edge.weight << endl;
        }
    }
};

int main() {
    Graph g(4);
    g.add_edge(0, 1, 10);
    g.add_edge(0, 2, 6);
    g.add_edge(0, 3, 5);
    g.add_edge(1, 3, 15);
    g.add_edge(2, 3, 4);

    g.boruvka_mst();

    return 0;
}
Java 
import java.util.*;

// Edge class to represent edges in the graph
class Edge {
    int src, dest, weight;

    public Edge(int src, int dest, int weight) {
        this.src = src;
        this.dest = dest;
        this.weight = weight;
    }
}

// Graph class to represent the graph and perform MST operations
class Graph {
    int V; // Number of vertices
    List<Edge> edges; // List to store graph edges

    public Graph(int vertices) {
        this.V = vertices;
        this.edges = new ArrayList<>();
    }

    // Function to add an edge to the graph
    public void addEdge(int u, int v, int w) {
        edges.add(new Edge(u, v, w));
    }

    // Find function to find the parent of a node
    public int find(int[] parent, int i) {
        if (parent[i] == i)
            return i;
        return find(parent, parent[i]);
    }

    // Union function to perform union of two subsets
    public void union(int[] parent, int[] rank, int x, int y) {
        int rootX = find(parent, x);
        int rootY = find(parent, y);

        if (rank[rootX] < rank[rootY])
            parent[rootX] = rootY;
        else if (rank[rootX] > rank[rootY])
            parent[rootY] = rootX;
        else {
            parent[rootY] = rootX;
            rank[rootX]++;
        }
    }

    // Boruvka's algorithm to find Minimum Spanning Tree
    public void boruvkaMST() {
        int[] parent = new int[V];
        int[] rank = new int[V];
        List<Edge> mstEdges = new ArrayList<>();

        int mstWeight = 0;
        int numOfTrees = V;

        // Initialize each vertex as its own parent
        for (int node = 0; node < V; ++node)
            parent[node] = node;

        // Iterate until all vertices are in one component
        while (numOfTrees > 1) {
            Edge[] cheapest = new Edge[V];
            Arrays.fill(cheapest, null);

            // Traverse through all edges and update cheapest of every component
            for (Edge edge : edges) {
                int set1 = find(parent, edge.src);
                int set2 = find(parent, edge.dest);

                if (set1 != set2) {
                    if (cheapest[set1] == null || edge.weight < cheapest[set1].weight)
                        cheapest[set1] = edge;

                    if (cheapest[set2] == null || edge.weight < cheapest[set2].weight)
                        cheapest[set2] = edge;
                }
            }

            // Add the cheapest edges to the MST
            for (int node = 0; node < V; ++node) {
                if (cheapest[node] != null) {
                    Edge edge = cheapest[node];
                    int set1 = find(parent, edge.src);
                    int set2 = find(parent, edge.dest);

                    if (set1 != set2) {
                        mstWeight += edge.weight;
                        union(parent, rank, set1, set2);
                        mstEdges.add(edge);
                        numOfTrees--;
                    }
                }
            }
        }

        // Print the weight of MST and edges in MST
        System.out.println("Weight of MST is " + mstWeight);
        System.out.println("Edges in MST are:");
        for (Edge edge : mstEdges) {
            System.out.println(edge.src + " -- " + edge.dest + " == " + edge.weight);
        }
    }

    public static void main(String[] args) {
        Graph g = new Graph(4);
        g.addEdge(0, 1, 10);
        g.addEdge(0, 2, 6);
        g.addEdge(0, 3, 5);
        g.addEdge(1, 3, 15);
        g.addEdge(2, 3, 4);

        g.boruvkaMST();
    }
}
Python 
class Graph:
    def __init__(self, vertices):
        self.V = vertices  # Number of vertices
        self.graph = []  # List to store graph edges

    def add_edge(self, u, v, w):
        self.graph.append([u, v, w])

    def find(self, parent, i):
        if parent[i] == i:
            return i
        return self.find(parent, parent[i])

    def union(self, parent, rank, x, y):
        root_x = self.find(parent, x)
        root_y = self.find(parent, y)

        if rank[root_x] < rank[root_y]:
            parent[root_x] = root_y
        elif rank[root_x] > rank[root_y]:
            parent[root_y] = root_x
        else:
            parent[root_y] = root_x
            rank[root_x] += 1

    def boruvka_mst(self):
        parent = []
        rank = []

        mst_weight = 0
        num_of_trees = self.V
        mst_edges = []

        for node in range(self.V):
            parent.append(node)
            rank.append(0)

        while num_of_trees > 1:
            cheapest = [-1] * self.V

            for u, v, w in self.graph:
                set1 = self.find(parent, u)
                set2 = self.find(parent, v)

                if set1 != set2:
                    if cheapest[set1] == -1 or cheapest[set1][2] > w:
                        cheapest[set1] = [u, v, w]

                    if cheapest[set2] == -1 or cheapest[set2][2] > w:
                        cheapest[set2] = [u, v, w]

            for node in range(self.V):
                if cheapest[node] != -1:
                    u, v, w = cheapest[node]
                    set1 = self.find(parent, u)
                    set2 = self.find(parent, v)

                    if set1 != set2:
                        mst_weight += w
                        self.union(parent, rank, set1, set2)
                        mst_edges.append([u, v, w])
                        num_of_trees -= 1

        print("Weight of MST is", mst_weight)
        print("Edges in MST are:")
        for u, v, weight in mst_edges:
            print(f"{u} -- {v} == {weight}")

# Example usage
g = Graph(4)
g.add_edge(0, 1, 10)
g.add_edge(0, 2, 6)
g.add_edge(0, 3, 5)
g.add_edge(1, 3, 15)
g.add_edge(2, 3, 4)

g.boruvka_mst()

Output
Weight of MST is 19
Edges in MST are:
0 -- 3 == 5
0 -- 1 == 10
2 -- 3 == 4

This output indicates that the MST has a total weight of 19, and the edges included in the MST are (2, 3), (0, 3), and (0, 1).

How Boruvka's Algorithm Works - Steps

  1. Initialize the Graph: Create an instance of the Graph class with the number of vertices.
  2. Add Edges: Use the add_edge method to add edges between vertices with their respective weights.
  3. Define Union-Find Operations:
    • find: Determine the root of a vertex.
    • union: Merge two components.
  4. Implement Boruvka's Algorithm:
    • Initialize parent and rank arrays.
    • Loop until the number of trees reduces to one.
    • Find the cheapest edge for each component.
    • Add the cheapest edges to the MST and update the components.
  5. Print the MST: Display the total weight and edges of the MST.

Implementation of Boruvka's Algorithm in Python

Here's a step-by-step implementation of Boruvka's Algorithm in Python:

Step 1: Define the Graph

First, let's define the graph using an edge list representation. Each edge is represented as a tuple (u, v, w), where u and v are the vertices and w is the weight of the edge.

Python 
class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = []

    def add_edge(self, u, v, w):
        self.graph.append([u, v, w])

Step 2: Find the Component of a Vertex

To efficiently find the component of a vertex, we use the Disjoint Set Union (DSU) or Union-Find data structure with path compression and union by rank.

Python 
class DisjointSet:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, u):
        if self.parent[u] != u:
            self.parent[u] = self.find(self.parent[u])
        return self.parent[u]

    def union(self, u, v):
        root_u = self.find(u)
        root_v = self.find(v)
        if root_u != root_v:
            if self.rank[root_u] > self.rank[root_v]:
                self.parent[root_v] = root_u
            elif self.rank[root_u] < self.rank[root_v]:
                self.parent[root_u] = root_v
            else:
                self.parent[root_v] = root_u
                self.rank[root_u] += 1

Step 3: Implement Boruvka's Algorithm

Now, we implement the core logic of Boruvka's Algorithm.

Python 
def boruvkas_algorithm(graph):
    V, edges = graph.V, graph.graph
    disjoint_set = DisjointSet(V)

    mst = []
    num_of_components = V

    while num_of_components > 1:
        cheapest = [-1] * V

        for u, v, w in edges:
            set_u = disjoint_set.find(u)
            set_v = disjoint_set.find(v)

            if set_u != set_v:
                if cheapest[set_u] == -1 or cheapest[set_u][2] > w:
                    cheapest[set_u] = [u, v, w]
                if cheapest[set_v] == -1 or cheapest[set_v][2] > w:
                    cheapest[set_v] = [u, v, w]

        for node in range(V):
            if cheapest[node] != -1:
                u, v, w = cheapest[node]
                set_u = disjoint_set.find(u)
                set_v = disjoint_set.find(v)

                if set_u != set_v:
                    mst.append([u, v, w])
                    disjoint_set.union(set_u, set_v)
                    num_of_components -= 1

    return mst

Example Usage

Here is how you can use the above code to find the MST of a given graph.

Python 
# Create a graph
g = Graph(4)
g.add_edge(0, 1, 10)
g.add_edge(0, 2, 6)
g.add_edge(0, 3, 5)
g.add_edge(1, 3, 15)
g.add_edge(2, 3, 4)

# Find the MST using Boruvka's algorithm
mst = boruvkas_algorithm(g)

# Print the MST
print("Edges in the Minimum Spanning Tree:")
for u, v, weight in mst:
    print(f"{u} -- {v} == {weight}")

Output:

Edges in the Minimum Spanning Tree: 
0 -- 3 == 5 
0 -- 1 == 10 
2 -- 3 == 4

Advantages of Boruvka's Algorithm

  • Parallelism: The algorithm can be easily parallelized because the cheapest edge for each component can be found independently.
  • Efficiency: It works well for sparse graphs due to its step-by-step edge addition process.

By following these steps, you can implement Boruvka's Algorithm in Python and find the MST of a given graph. This algorithm is particularly useful for understanding graph theory concepts and solving real-world problems involving network design.

Conclusion

Boruvka's algorithm is an efficient way to find the Minimum Spanning Tree in a graph. It is particularly useful for sparse graphs and can be easily parallelized. The implementation in Python involves defining the graph, utilizing the Disjoint Set Union data structure, and repeatedly finding and adding the cheapest edges to the MST. This step-by-step approach ensures that the algorithm is both easy to understand and efficient in practice.


R
rushisoni2003
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox