Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Implement Kruskals Algorithm in Golang
In this article we are going to understand how to develop a golang program to implement kruskals Algorithm with the help of union-find Algorithm and priority queue approach. Kruskal's Algorithm is used to find the minimum spanning tree of a graph.
Algorithm
Step 1 − First, we need to import the fmt and sort packages. Then create structures called Edge, graph and subset and assign properties to it.
Step 2 − Then sort all the edges of the graph in non-decreasing order of their weight.
Step 3 − Create a disjoint set data structure, where each set contains only one vertex.
Step 4 − For each edge in the sorted graph. If the edge connects two disjoint sets then we need to add it to the minimum spanning tree and merge the two sets. At last return the minimum spanning tree.
Step 5 − Now, start the main() function. Inside the main() function initialize a graph and assign edges to it. Further call the kruskals() function by passing the edge as argument to it.
Step 6 − Store the result obtained by the function in a variable and print them on the screen.
Example 1
In this Example we will write a go language program to implement Kruskals Algorithm by using union-find Algorithm.
package main
import (
"fmt"
"sort"
)
type Edge struct {
Src, Dest, Weight int
}
type Graph struct {
Edges []Edge
Vertices int
}
type Subset struct {
Parent int
Rank int
}
func find(subsets []Subset, i int) int {
if subsets[i].Parent != i {
subsets[i].Parent = find(subsets, subsets[i].Parent)
}
return subsets[i].Parent
}
func union(subsets []Subset, x, y int) {
rootX := find(subsets, x)
rootY := find(subsets, y)
if subsets[rootX].Rank < subsets[rootY].Rank {
subsets[rootX].Parent = rootY
} else if subsets[rootX].Rank > subsets[rootY].Rank {
subsets[rootY].Parent = rootX
} else {
subsets[rootY].Parent = rootX
subsets[rootX].Rank++
}
}
func kruskals(graph Graph) []Edge {
sortedEdges := make([]Edge, len(graph.Edges))
copy(sortedEdges, graph.Edges)
sort.Slice(sortedEdges, func(i, j int) bool {
return sortedEdges[i].Weight < sortedEdges[j].Weight
})
subsets := make([]Subset, graph.Vertices)
for i := range subsets {
subsets[i].Parent = i
subsets[i].Rank = 0
}
result := make([]Edge, 0, graph.Vertices-1)
for _, edge := range sortedEdges {
srcRoot := find(subsets, edge.Src)
destRoot := find(subsets, edge.Dest)
if srcRoot != destRoot {
result = append(result, edge)
union(subsets, srcRoot, destRoot)
}
}
return result
}
func main() {
graph := Graph{
Edges: []Edge{
{0, 1, 10},
{0, 2, 6},
{0, 3, 5},
{1, 3, 15},
{2, 3, 4},
},
Vertices: 4,
}
fmt.Println("The given input is:", graph)
fmt.Println()
mst := kruskals(graph)
fmt.Println("Minimum Spanning Tree:")
for _, edge := range mst {
fmt.Printf("(%d, %d) with weight %d\n", edge.Src, edge.Dest, edge.Weight)
}
}
Output
The given input is: {[{0 1 10} {0 2 6} {0 3 5} {1 3 15} {2 3 4}] 4}
Minimum Spanning Tree:
(2, 3) with weight 4
(0, 3) with weight 5
(0, 1) with weight 10
Example 2
In this Example we will write a go language program to implement the kruskals Algorithm by using the priority queue Algorithm.
package main
import (
"container/heap"
"fmt"
)
type Edge struct {
Src int
Dest int
Weight int
}
type Graph struct {
Edges []Edge
Vertices int
}
type PriorityQueue []*Item
type Item struct {
value Edge
priority int
index int
}
func (pq PriorityQueue) Len() int { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool {
return pq[i].priority < pq[j].priority
}
func (pq PriorityQueue) Swap(i, j int) {
pq[i], pq[j] = pq[j], pq[i]
pq[i].index = i
pq[j].index = j
}
func (pq *PriorityQueue) Push(x interface{}) {
n := len(*pq)
item := x.(*Item)
item.index = n
*pq = append(*pq, item)
}
func (pq *PriorityQueue) Pop() interface{} {
old := *pq
n := len(old)
item := old[n-1]
item.index = -1 // for safety
*pq = old[0 : n-1]
return item
}
func find(subsets []int, i int) int {
if subsets[i] != i {
subsets[i] = find(subsets, subsets[i])
}
return subsets[i]
}
func union(subsets []int, x int, y int) {
xroot := find(subsets, x)
yroot := find(subsets, y)
subsets[yroot] = xroot
}
func kruskals(graph Graph) []Edge {
pq := make(PriorityQueue, len(graph.Edges))
for i, edge := range graph.Edges {
pq[i] = &Item{
value: edge,
priority: edge.Weight,
index: i,
}
}
heap.Init(&pq)
subsets := make([]int, graph.Vertices)
for i := range subsets {
subsets[i] = i
}
result := make([]Edge, 0, graph.Vertices-1)
for pq.Len() > 0 {
item := heap.Pop(&pq).(*Item)
edge := item.value
srcRoot := find(subsets, edge.Src)
destRoot := find(subsets, edge.Dest)
if srcRoot != destRoot {
result = append(result, edge)
// Update the parent node of the subset containing the src vertex
union(subsets, edge.Src, edge.Dest)
}
}
return result
}
func main() {
graph := Graph{
Edges: []Edge{
{0, 1, 10},
{0, 2, 6},
{0, 3, 5},
{1, 3, 15},
{2, 3, 4},
},
Vertices: 4,
}
fmt.Println("The given input is:", graph)
mst := kruskals(graph)
fmt.Println()
fmt.Println("Minimum Spanning Tree:")
for _, edge := range mst {
fmt.Printf("(%d, %d) with weight %d\n", edge.Src, edge.Dest, edge.Weight)
}
}
Output
The given input is: {[{0 1 10} {0 2 6} {0 3 5} {1 3 15} {2 3 4}] 4}
Minimum Spanning Tree:
(2, 3) with weight 4
(0, 3) with weight 5
(0, 1) with weight 10
Conclusion
We have successfully compiled and executed a go language program to implement the Kruskal's Algorithm along with Examples.
199 Views
