Update algorithms

Author: code-shoily

algo/graphs/topsort.go

@@ -0,0 +1,91 @@
+package graphs
+
+import (
+	"container/heap"
+	"github.com/code-shoily/aocgo/algo"
+)
+
+// TopologicalSort performs a topological sort based on FIFO and returns the sorted order (nil if cycle) and cycle
+func TopologicalSort(g *Graph) (sorted []string, cycle bool) {
+	var count int
+	inDegrees := make(map[string]int)
+	queue := algo.NewQueue()
+
+	for _, vertex := range g.Vertices() {
+		if inDegree := len(vertex.incoming); inDegree == 0 {
+			queue.Enqueue(vertex.ID())
+		} else {
+			inDegrees[vertex.ID()] += inDegree
+		}
+	}
+
+	for !queue.IsEmpty() {
+		if vertexAny, empty := queue.Dequeue(); !empty {
+			vertexID := vertexAny.(string)
+			sorted = append(sorted, vertexID)
+
+			for outgoing, _ := range g.Vertices()[vertexID].outgoing {
+				outgoingID := outgoing.ID()
+				inDegrees[outgoingID]--
+
+				if inDegrees[outgoingID] == 0 {
+					queue.Enqueue(outgoingID)
+				}
+			}
+		}
+		count++
+	}
+
+	if count != len(g.Vertices()) {
+		return nil, true
+	}
+
+	return sorted, cycle
+}
+
+func lexicographicalSorter(g *Graph, h heap.Interface) (sorted []string, cycle bool) {
+	var count int
+	inDegrees := make(map[string]int)
+	heap.Init(h)
+
+	for _, vertex := range g.Vertices() {
+		if inDegree := len(vertex.incoming); inDegree == 0 {
+			heap.Push(h, vertex.ID())
+		} else {
+			inDegrees[vertex.ID()] += inDegree
+		}
+	}
+
+	for h.Len() != 0 {
+		vertexAny := heap.Pop(h)
+		vertexID := vertexAny.(string)
+		sorted = append(sorted, vertexID)
+
+		for outgoing, _ := range g.Vertices()[vertexID].outgoing {
+			outgoingID := outgoing.ID()
+			inDegrees[outgoingID]--
+
+			if inDegrees[outgoingID] == 0 {
+				heap.Push(h, outgoingID)
+			}
+		}
+
+		count++
+	}
+
+	if count != len(g.Vertices()) {
+		return nil, true
+	}
+
+	return sorted, cycle
+}
+
+// LexicographicalTopologicalSort returns sort in ascending order of keys unless a cycle is detected.
+func LexicographicalTopologicalSort(g *Graph) (sorted []string, cycle bool) {
+	return lexicographicalSorter(g, &algo.Heap[string]{})
+}
+
+// LexicographicalReverseTopologicalSort returns sort in descending order of keys unless a cycle is detected.
+func LexicographicalReverseTopologicalSort(g *Graph) (sorted []string, cycle bool) {
+	return lexicographicalSorter(g, &algo.MaxHeap[string]{})
+}

algo/graphs/topsort_test.go

@@ -0,0 +1,82 @@
+package graphs
+
+import (
+	"reflect"
+	"testing"
+)
+
+func MakeGraph() *Graph {
+	g := NewGraph(true)
+	for _, vertexID := range []string{"0", "1", "2", "3", "4", "5"} {
+		g.AddVertex(NewSimpleVertex(vertexID))
+	}
+	g.AddEdge("2", "3", 1)
+	g.AddEdge("3", "1", 1)
+	g.AddEdge("4", "0", 1)
+	g.AddEdge("4", "1", 1)
+	g.AddEdge("5", "2", 1)
+	g.AddEdge("5", "0", 1)
+
+	return g
+}
+
+func MakeGraphWithCycle() *Graph {
+	g := NewGraph(true)
+	for _, vertexID := range []string{"0", "1", "2", "3", "4", "5"} {
+		g.AddVertex(NewSimpleVertex(vertexID))
+	}
+	g.AddEdge("2", "3", 1)
+	g.AddEdge("3", "1", 1)
+	g.AddEdge("4", "0", 1)
+	g.AddEdge("4", "1", 1)
+	g.AddEdge("5", "2", 1)
+	g.AddEdge("5", "0", 1)
+	g.AddEdge("3", "2", 1)
+
+	return g
+}
+
+func TestTopologicalSort(t *testing.T) {
+	graph := MakeGraph()
+	expect := []string{"4", "5", "2", "0", "3", "1"}
+	if sorted, cycle := TopologicalSort(graph); !reflect.DeepEqual(sorted, expect) || cycle {
+		t.Errorf("Fail - expected %v/%v but got %v/%v", expect, false, sorted, cycle)
+	}
+}
+
+func TestTopologicalSortCycled(t *testing.T) {
+	graph := MakeGraphWithCycle()
+	if _, cycle := TopologicalSort(graph); !cycle {
+		t.Errorf("Fail - expected %v but got %v", true, cycle)
+	}
+}
+
+func TestLexicographicalTopologicalSort(t *testing.T) {
+	graph := MakeGraph()
+	expect := []string{"4", "5", "0", "2", "3", "1"}
+	if sorted, cycle := LexicographicalTopologicalSort(graph); !reflect.DeepEqual(sorted, expect) || cycle {
+		t.Errorf("Fail - expected %v/%v but got %v/%v", expect, false, sorted, cycle)
+	}
+}
+
+func TestLexicographicalTopologicalSortCycled(t *testing.T) {
+	graph := MakeGraphWithCycle()
+	if _, cycle := LexicographicalTopologicalSort(graph); !cycle {
+		t.Errorf("Fail - expected %v but got %v", true, cycle)
+	}
+}
+
+func TestLexicographicalReverseTopologicalSort(t *testing.T) {
+	graph := MakeGraph()
+	expect := []string{"5", "4", "2", "3", "1", "0"}
+	if sorted, cycle := LexicographicalReverseTopologicalSort(graph); !reflect.DeepEqual(sorted, expect) || cycle {
+		t.Errorf("Fail - expected %v/%v but got %v/%v", expect, false, sorted, cycle)
+	}
+}
+
+func TestLexicographicalReverseTopologicalSortCycled(t *testing.T) {
+	graph := MakeGraphWithCycle()
+	if _, cycle := LexicographicalReverseTopologicalSort(graph); !cycle {
+		t.Errorf("Fail - expected %v but got %v", true, cycle)
+	}
+}

algo/queue.go

@@ -3,39 +3,39 @@ package algo
 import "container/list"
 
 // NewQueue creates a new Queue
-func NewQueue[T any]() *Queue[T] {
-	return &Queue[T]{list.New()}
+func NewQueue() *Queue {
+	return &Queue{list.New()}
 }
 
-type Queue[T any] struct {
+type Queue struct {
 	*list.List
 }
 
 // Enqueue insers a new element on the queue
-func (q *Queue[T]) Enqueue(elem T) {
+func (q *Queue) Enqueue(elem any) {
 	q.PushBack(elem)
 }
 
 // Dequeue removes and returns the oldest element from the queue
-func (q *Queue[T]) Dequeue() (elem T, empty bool) {
+func (q *Queue) Dequeue() (elem any, empty bool) {
 	if q.IsEmpty() {
 		return elem, true
 	}
 	front := q.Front()
 	q.Remove(front)
 
-	return front.Value.(T), false
+	return front.Value, false
 }
 
 // Peek shows the oldest element in the queue without removing anything
-func (q *Queue[T]) Peek() (elem T, empty bool) {
+func (q *Queue) Peek() (elem any, empty bool) {
 	if q.IsEmpty() {
 		return elem, true
 	}
-	return q.Front().Value.(T), false
+	return q.Front().Value, false
 }
 
 // IsEmpty checks if the queue is empty
-func (q *Queue[T]) IsEmpty() bool {
+func (q *Queue) IsEmpty() bool {
 	return q.Len() == 0
 }

algo/queue_test.go

@@ -3,7 +3,7 @@ package algo
 import "testing"
 
 func TestQueue_IsEmpty(t *testing.T) {
-	queue := NewQueue[string]()
+	queue := NewQueue()
 
 	if empty := queue.IsEmpty(); !empty {
 		t.Errorf("Fail - expected the queue to be empty")
@@ -23,7 +23,7 @@ func TestQueue_IsEmpty(t *testing.T) {
 }
 
 func TestQueue_EnqueueDeque(t *testing.T) {
-	queue := NewQueue[int]()
+	queue := NewQueue()
 	queue.Enqueue(1)
 	queue.Enqueue(2)
 	queue.Enqueue(3)
@@ -37,13 +37,13 @@ func TestQueue_EnqueueDeque(t *testing.T) {
 	if e, notEmpty := queue.Dequeue(); e != 3 || notEmpty {
 		t.Errorf("Fail - %v/%v expected, got %v/%v", 1, false, e, notEmpty)
 	}
-	if e, empty := queue.Dequeue(); e != 0 || !empty {
+	if e, empty := queue.Dequeue(); e != nil || !empty {
 		t.Errorf("Fail - %v/%v expected, got %v/%v", 1, true, e, empty)
 	}
 }
 
 func TestQueue_Peek(t *testing.T) {
-	queue := NewQueue[int]()
+	queue := NewQueue()
 	queue.Enqueue(1)
 	if e, notEmpty := queue.Peek(); e != 1 || notEmpty {
 		t.Errorf("Fail - %v/%v expected, got %v/%v", 1, false, e, notEmpty)
@@ -63,7 +63,7 @@ func TestQueue_Peek(t *testing.T) {
 	queue.Dequeue()
 	queue.Dequeue()
 
-	if e, empty := queue.Peek(); e != 0 || !empty {
+	if e, empty := queue.Peek(); e != nil || !empty {
 		t.Errorf("Fail - %v/%v expected, got %v/%v", 1, true, e, empty)
 	}
 }