add topological

Author: shellfly

README.md

@@ -50,18 +50,22 @@ To test each algorithm(data structure), instead of running the file directly, yo
   * [LinearProbingHashST](linear_probing_hash_st.go)
 
 * 4 GRAPHS
-
-  * [Graph](graph.go)
-  * [DepthFirstSearch](depth_first_search.go)
-  * [DepthFirstPaths](depth_first_paths.go)
-  * [BreadthFirstPaths](breadth_first_paths.go)
-  * [CC](cc.go)
-  * [Cycle](cycle.go)
-  * [SymbolGraph](symbol_graph.go)
-  * [DegreesOfSeparation](cmd/degrees-of-separation/main.go)
-  * [Digraph](digraph.go)
-  * [DirectedDFS](directed_dfs.go)
-  * [DirectedCycle](directed_cycle.go)
+  * Graph
+    * [Graph](graph.go)
+    * [DepthFirstSearch](depth_first_search.go)
+    * [DepthFirstPaths](depth_first_paths.go)
+    * [BreadthFirstPaths](breadth_first_paths.go)
+    * [CC](cc.go)
+    * [Cycle](cycle.go)
+    * [SymbolGraph](symbol_graph.go)
+    * [DegreesOfSeparation](cmd/degrees-of-separation/main.go)
+  * Digraph
+    * [Digraph](digraph.go)
+    * [SymbolDigraph](symbol_digraph.go)
+    * [DirectedDFS](directed_dfs.go)
+    * [DirectedCycle](directed_cycle.go)
+    * [DepthFirstOrder](depth_first_order.go)
+    * [Topological](topological.go)
 
 * 5 STRING
 

cmd/topological/main.go

@@ -0,0 +1,44 @@
+/******************************************************************************
+ *  Execution:    go run cmd/topological/main.go filename.txt delimiter
+ *  Dependencies: Digraph.java DepthFirstOrder.java DirectedCycle.java
+ *                EdgeWeightedDigraph.java EdgeWeightedDirectedCycle.java
+ *                SymbolDigraph.java
+ *  Data files:   https://algs4.cs.princeton.edu/42digraph/jobs.txt
+ *
+ *  Compute topological ordering of a DAG or edge-weighted DAG.
+ *  Runs in O(E + V) time.
+ *
+ *  % go run cmd/topological/main.go jobs.txt "/"
+ *  Calculus
+ *  Linear Algebra
+ *  Introduction to CS
+ *  Advanced Programming
+ *  Algorithms
+ *  Theoretical CS
+ *  Artificial Intelligence
+ *  Robotics
+ *  Machine Learning
+ *  Neural Networks
+ *  Databases
+ *  Scientific Computing
+ *  Computational Biology
+ *
+ ******************************************************************************/
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/shellfly/algo"
+)
+
+func main() {
+	filename, sp := os.Args[1], os.Args[2]
+	sg := algo.NewSymbolDigraph(filename, sp)
+	top := algo.NewTopological(sg.G())
+	for _, v := range top.Order() {
+		fmt.Println(sg.Name(v))
+	}
+}

depth_first_order.go

@@ -0,0 +1,52 @@
+package algo
+
+// DepthFirstOrder ...
+type DepthFirstOrder struct {
+	marked      []bool
+	pre, post   *Queue
+	reversePost *Stack
+}
+
+// NewDepthFirstOrder ...
+func NewDepthFirstOrder(g *Digraph) *DepthFirstOrder {
+	d := &DepthFirstOrder{
+		marked:      make([]bool, g.V()),
+		pre:         NewQueue(),
+		post:        NewQueue(),
+		reversePost: NewStack(),
+	}
+	for v := 0; v < g.V(); v++ {
+		if !d.marked[v] {
+			d.Dfs(g, v)
+		}
+	}
+	return d
+}
+
+// Dfs ...
+func (d *DepthFirstOrder) Dfs(g *Digraph, v int) {
+	d.pre.Enqueue(v)
+	d.marked[v] = true
+	for _, w := range g.Adj(v) {
+		if !d.marked[w] {
+			d.Dfs(g, w)
+		}
+	}
+	d.post.Enqueue(v)
+	d.reversePost.Push(v)
+}
+
+// Pre ...
+func (d *DepthFirstOrder) Pre() *Queue {
+	return d.pre
+}
+
+// Post ...
+func (d *DepthFirstOrder) Post() *Queue {
+	return d.post
+}
+
+// ReversePost ...
+func (d *DepthFirstOrder) ReversePost() *Stack {
+	return d.reversePost
+}

symbol_digraph.go

@@ -0,0 +1,64 @@
+package algo
+
+import (
+	"strings"
+
+	"github.com/shellfly/algo/stdin"
+)
+
+// SymbolDigraph ...
+type SymbolDigraph struct {
+	st   ST
+	keys []string
+	g    *Digraph
+}
+
+// NewSymbolDigraph ...
+func NewSymbolDigraph(filename, sp string) *SymbolDigraph {
+	st := NewST()
+	in := stdin.NewInByLine(filename)
+	for !in.IsEmpty() {
+		a := strings.Split(in.ReadString(), sp)
+		for i := 0; i < len(a); i++ {
+			if !st.Contains(a[i]) {
+				st.Put(a[i], st.Size())
+			}
+		}
+	}
+
+	keys := make([]string, st.Size())
+	for _, name := range st.Keys() {
+		keys[st.Get(name)] = name
+	}
+
+	g := NewDigraphV(st.Size())
+	in = stdin.NewInByLine(filename)
+	for !in.IsEmpty() {
+		a := strings.Split(in.ReadString(), sp)
+		v := st.Get(a[0])
+		for i := 1; i < len(a); i++ {
+			g.AddEdge(v, st.Get(a[i]))
+		}
+	}
+	return &SymbolDigraph{st, keys, g}
+}
+
+// Contains ...
+func (s *SymbolDigraph) Contains(key string) bool {
+	return s.st.Contains(key)
+}
+
+// Index ...
+func (s *SymbolDigraph) Index(key string) int {
+	return s.st.Get(key)
+}
+
+// Name ...
+func (s *SymbolDigraph) Name(v int) string {
+	return s.keys[v]
+}
+
+// G ...
+func (s *SymbolDigraph) G() *Digraph {
+	return s.g
+}

symbol_graph.go

@@ -34,7 +34,7 @@ func NewSymbolGraph(filename, sp string) *SymbolGraph {
 	g := NewGraphV(st.Size())
 	in = stdin.NewInByLine(filename)
 	for !in.IsEmpty() {
-		a := strings.Split(in.ReadString(), " ")
+		a := strings.Split(in.ReadString(), sp)
 		v := st.Get(a[0])
 		for i := 1; i < len(a); i++ {
 			g.AddEdge(v, st.Get(a[i]))

topological.go

@@ -0,0 +1,31 @@
+package algo
+
+// Topological ...
+type Topological struct {
+	order []int
+}
+
+// NewTopological ...
+func NewTopological(g *Digraph) *Topological {
+	t := new(Topological)
+	cycleFinder := NewDirectedCycle(g)
+	if !cycleFinder.HasCycle() {
+		dfs := NewDepthFirstOrder(g)
+		order := []int{}
+		for _, v := range dfs.ReversePost().Slice() {
+			order = append(order, v.(int))
+		}
+		t.order = order
+	}
+	return t
+}
+
+// Order ...
+func (t *Topological) Order() []int {
+	return t.order
+}
+
+// IsDAG ...
+func (t *Topological) IsDAG() bool {
+	return t.order != nil
+}