create Dijkstra

Author: rihib

basics/graph/dijkstra.go

@@ -0,0 +1,43 @@
+package graph
+
+import (
+	"container/heap"
+	"math"
+)
+
+type Edge struct {
+	To     int
+	Weight int
+}
+
+// adjacency list
+type Graph struct {
+	Nodes map[int][]Edge
+}
+
+func (g *Graph) Dijkstra(source int) map[int]int {
+	dist := make(map[int]int)
+	for node := range g.Nodes {
+		dist[node] = math.MaxInt64
+	}
+	dist[source] = 0
+
+	pq := make(PriorityQueue, 0)
+	heap.Init(&pq)
+	heap.Push(&pq, &Item{Node: source, Priority: 0})
+
+	for pq.Len() > 0 {
+		u := heap.Pop(&pq).(*Item).Node
+
+		for _, edge := range g.Nodes[u] {
+			v := edge.To
+			weight := edge.Weight
+			if dist[u]+weight < dist[v] {
+				dist[v] = dist[u] + weight
+				heap.Push(&pq, &Item{Node: v, Priority: dist[v]})
+			}
+		}
+	}
+
+	return dist
+}

basics/graph/priorityqueue.go

@@ -0,0 +1,37 @@
+package graph
+
+type PriorityQueue []*Item
+
+type Item struct {
+	Node     int
+	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
+	*pq = old[0 : n-1]
+	return item
+}

basics/main.go

@@ -6,13 +6,15 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/rihib/leetcode/basics/graph"
 	"github.com/rihib/leetcode/basics/queue"
 	"github.com/rihib/leetcode/basics/sort"
 )
 
 func main() {
 	testSort()
 	testPriorityQueue()
+	testDijkstra()
 }
 
 func testSort() {
@@ -109,4 +111,22 @@ func testPriorityQueue() {
 
 	node, l, isEmpty = pq.Peek(), pq.Len(), pq.IsEmpty()
 	fmt.Printf("Peek returns nil: %t, Len: %d, IsEmpty: %t\n", node == nil, l, isEmpty)
+
+	fmt.Println("")
+}
+
+func testDijkstra() {
+	fmt.Println("=====Dijkstra=====")
+	g := &graph.Graph{
+		Nodes: make(map[int][]graph.Edge),
+	}
+	g.Nodes[0] = []graph.Edge{{To: 1, Weight: 4}, {To: 2, Weight: 1}}
+	g.Nodes[1] = []graph.Edge{{To: 3, Weight: 1}}
+	g.Nodes[2] = []graph.Edge{{To: 1, Weight: 2}, {To: 3, Weight: 5}}
+	g.Nodes[3] = []graph.Edge{}
+
+	dist := g.Dijkstra(0)
+	for node, distance := range dist {
+		fmt.Printf("Distance from node 0 to node %d is %d\n", node, distance)
+	}
 }