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
Golang program to implement dijikstra Algorithm to find shortest path between two nodes in a graph
In this Golang article, we will explore how to implement Dijkstra's Algorithm to find the shortest path between two nodes in a graph using an Adjacency Matrix as well as using an Adjacency List. Dijkstra's Algorithm is used to solve the single-source shortest path problem in a graph with non-negative edge weights.
Algorithm
Step 1 − First, we need to import the fmt and math packages. Then create a dist array of length n (the number of nodes in the graph) and initialize it with math.MaxInt32. This array will store the shortest distance from the starting node to every other node in the graph.
Step 2 − Then create a function named dijikastra that accepts the graph and two integers as arguments.
Step 3 − Inside the function create a visited array of length n and initialize it with false. This array will keep track of which nodes have already been visited.
Step 4 − Set dist[start] to 0, where start is the index of the starting node. Repeat the following n-1 times.
Step 5 − Find the node u that has not been visited yet and has the shortest distance to the starting node (i.e., dist[u] is the minimum among all nodes that have not been visited yet). Mark u as visited.
Step 6 − For each neighbor v of u, if dist[u] + graph[u][v] is less than the current dist[v], update dist[v] to dist[u] + graph[u][v]. Then return the dist array.
Step 7 − Here, graph is the adjacency matrix of the graph, where graph[i][j] represents the weight of the edge from node i to node j. If there is no edge between nodes i and j, graph[i][j] should be 0.
Example 1
An adjacency matrix is a 2D array used to represent a graph where the rows and columns represent the vertices, and the values represent the weights of the edges between them. To implement Dijkstra's Algorithm using an adjacency matrix, we can create a 2D array then initialize the distances to infinity, and then iterate over the vertices.
package main
import (
"fmt"
"math"
)
func dijkstra(graph [][]int, start int, end int) []int {
n := len(graph)
dist := make([]int, n)
visited := make([]bool, n)
for i := 0; i < n; i++ {
dist[i] = math.MaxInt32
visited[i] = false
}
dist[start] = 0
for count := 0; count < n-1; count++ {
u := -1
for i := 0; i < n; i++ {
if !visited[i] && (u == -1 || dist[i] < dist[u]) {
u = i
}
}
if u == -1 {
break
}
visited[u] = true
for v := 0; v < n; v++ {
if graph[u][v] != 0 && dist[u]+graph[u][v] < dist[v] {
dist[v] = dist[u] + graph[u][v]
}
}
}
return dist
}
func main() {
graph := [][]int{
{0, 5, 0, 9, 0},
{5, 0, 2, 0, 0},
{0, 2, 0, 3, 7},
{9, 0, 3, 0, 0},
{0, 0, 7, 0, 0},
}
fmt.Println("The given nodes are:", graph)
start := 0
end := 4
dist := dijkstra(graph, start, end)
fmt.Printf("Shortest path from node %d to %d: %d\n", start, end, dist[end])
}
Output
The given nodes are: [[0 5 0 9 0] [5 0 2 0 0] [0 2 0 3 7] [9 0 3 0 0] [0 0 7 0 0]] Shortest path from node 0 to 4: 14
Example 2
An adjacency list is a data structure used to represent a graph where each vertex is associated with a list of its neighboring vertices. To implement Dijkstra's Algorithm using an adjacency list, we can create a map where the keys are the vertices and the values are slices of their neighboring vertices and their weights.
package main
import (
"container/heap"
"fmt"
"math"
)
type node struct {
index int
dist int
}
type priorityQueue []*node
func (pq priorityQueue) Len() int {
return len(pq)
}
func (pq priorityQueue) Less(i, j int) bool {
return pq[i].dist < pq[j].dist
}
func (pq priorityQueue) Swap(i, j int) {
pq[i], pq[j] = pq[j], pq[i]
}
func (pq *priorityQueue) Push(x interface{}) {
*pq = append(*pq, x.(*node))
}
func (pq *priorityQueue) Pop() interface{} {
old := *pq
n := len(old)
x := old[n-1]
*pq = old[0 : n-1]
return x
}
func dijkstra(graph [][]node, start int, end int) []int {
n := len(graph)
dist := make([]int, n)
visited := make([]bool, n)
for i := 0; i < n; i++ {
dist[i] = math.MaxInt32
visited[i] = false
}
dist[start] = 0
pq := make(priorityQueue, 0)
heap.Push(&pq, &node{start, 0})
for pq.Len() > 0 {
u := heap.Pop(&pq).(*node)
if visited[u.index] {
continue
}
visited[u.index] = true
for _, v := range graph[u.index] {
if !visited[v.index] && dist[u.index]+v.dist < dist[v.index] {
dist[v.index] = dist[u.index] + v.dist
heap.Push(&pq, &node{v.index, dist[v.index]})
}
}
}
return dist
}
func main() {
graph := [][]node{
{{1, 5}, {3, 9}},
{{0, 5}, {2, 2}},
{{1, 2}, {3, 3}, {4, 7}},
{{0, 9}, {2, 3}},
{{2, 7}},
}
fmt.Println("The given nodes are:", graph)
start := 0
end := 4
dist := dijkstra(graph, start, end)
fmt.Printf("Shortest path from node %d to %d: %d\n", start, end, dist[end])
}
Output
The given nodes are: [[{1 5} {3 9}] [{0 5} {2 2}] [{1 2} {3 3} {4 7}] [{0 9} {2 3}] [{2 7}]]
Shortest path from node 0 to 4: 14
Conclusion
In this article, we explored how to implement Dijkstra's Algorithm in Go to find the shortest path between two nodes in a graph using two different methods: an adjacency matrix and an adjacency list. Both methods work well and have their own advantages and disadvantages. The adjacency matrix method is simple and easy to implement, but it requires more space for larger graphs. The adjacency list method is more space-efficient and can handle larger graphs, but it requires more time to traverse the neighbors of each vertex.
701 Views
