added graph traversals

Author: Morfly

src/kotlin/sequential/graph/bfs/BUILD

@@ -0,0 +1,14 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+kt_jvm_library(
+    name = "bfs_lib",
+    srcs = glob([
+        "*.kt",
+    ]),
+)
+
+java_binary(
+    name = "bfs",
+    main_class = "sequential.graph.bfs.BreadthFirstTraversalKt",
+    runtime_deps = [":bfs_lib"],
+)

src/kotlin/sequential/graph/bfs/BreadthFirstTraversal.kt

@@ -1,6 +1,6 @@
 package sequential.graph.bfs
 
-import kotlin.collections.ArrayDeque
+import java.util.*
 
 
 private typealias Graph<T> = Map<T, List<T>>
@@ -12,8 +12,9 @@ fun <T> Graph<T>.bfs(root: T): Collection<T> {
     val graph = this
 
     val explored = mutableSetOf<T>()
-    val searchQueue = Queue<T>(listOf(root))
+    val searchQueue = Queue<T>()
 
+    searchQueue.addLast(root)
     while (searchQueue.isNotEmpty()) {
         val node = searchQueue.removeFirst()
         explored.add(node)
@@ -23,7 +24,7 @@ fun <T> Graph<T>.bfs(root: T): Collection<T> {
             if (succ !in explored) searchQueue.addLast(succ)
         }
     }
-    
+
     return explored
 }
 

src/kotlin/sequential/graph/dfs/BUILD

@@ -0,0 +1,20 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+kt_jvm_library(
+    name = "dfs_lib",
+    srcs = glob([
+        "*.kt",
+    ]),
+)
+
+java_binary(
+    name = "dfs_iterative",
+    main_class = "sequential.graph.dfs.iterative.IterativeDepthFirstTraversalKt",
+    runtime_deps = [":dfs_lib"],
+)
+
+java_binary(
+    name = "dfs_recursive",
+    main_class = "sequential.graph.dfs.RecursiveDepthFirstTraversalKt",
+    runtime_deps = [":dfs_lib"],
+)

src/kotlin/sequential/graph/dfs/IterativeDepthFirstTraversal.kt

@@ -0,0 +1,34 @@
+package sequential.graph.dfs.iterative
+
+import java.util.*
+
+
+private typealias Graph<T> = Map<T, List<T>>
+
+private typealias Stack<T> = ArrayDeque<T>
+
+
+fun <T> Graph<T>.iterativeDfs(root: T): Collection<T> {
+    val graph = this
+
+    val explored = mutableSetOf<T>()
+    val stack = Stack<T>()
+
+    stack.addLast(root)
+    while (stack.isNotEmpty()) {
+        val node = stack.removeLast()
+        explored.add(node)
+
+        val successors = graph[node].orEmpty()
+        for (succ in successors) {
+            if (succ !in explored) stack.addLast(succ)
+        }
+    }
+
+    return explored
+}
+
+
+fun main() {
+
+}

src/kotlin/sequential/graph/dfs/RecursiveDepthFirstTraversal.kt

@@ -0,0 +1,28 @@
+package sequential.graph.dfs
+
+
+private typealias Graph<T> = Map<T, List<T>>
+
+
+fun <T> Graph<T>.dfs(root: T): Collection<T> {
+    val graph = this
+
+    val explored = mutableSetOf<T>()
+
+    fun explore(node: T) {
+        explored.add(node)
+
+        val successors = graph[node].orEmpty()
+        for (succ in successors) {
+            if (succ !in explored) explore(succ)
+        }
+    }
+    explore(root)
+
+    return explored
+}
+
+
+fun main() {
+
+}

src/kotlin/sequential/graph/dfs/iterative/DepthFirstTraversal.kt

@@ -0,0 +1,14 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+kt_jvm_library(
+    name = "dijkstra_lib",
+    srcs = glob([
+        "*.kt",
+    ]),
+)
+
+java_binary(
+    name = "dijkstra",
+    main_class = "sequential.graph.dijkstra.DijkstraKt",
+    runtime_deps = [":dijkstra_lib"],
+)

src/kotlin/sequential/graph/dijkstra/BUILD

@@ -0,0 +1,78 @@
+package sequential.graph.dijkstra
+
+
+/**
+ * Weighted graph representation using hash table.
+ * @param T graph value type.
+ */
+private typealias Graph<T> = Map<T, Map<T, Double>>
+
+/**
+ * Infinity value which is used as graph edge weight.
+ */
+private val INFINITY = Double.POSITIVE_INFINITY
+
+
+/**
+ * Finds shortest path to the [target] node using Dijkstra algorithm.
+ */
+fun <T> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
+    val graph = this
+
+    val costs = graph.getValue(root).toMutableMap()
+    val explored = mutableSetOf<T>()
+    val parents = graph.getValue(root).mapValues { root }.toMutableMap()
+
+    var node = costs.smallestCostNode(explored)
+    while (node != null) {
+        val nodeCost = costs[node]!!
+        val successors = graph[node].orEmpty()
+
+        for ((succ, edgeWeight) in successors) {
+            if (nodeCost + edgeWeight < costs[succ] ?: INFINITY) {
+                costs[succ] = nodeCost + edgeWeight
+                parents[succ] = node
+            }
+        }
+
+        explored.add(node)
+        node = costs.smallestCostNode(explored)
+    }
+
+    return pathToNode(target, parents)
+}
+
+private fun <T> Map<T, Double>.smallestCostNode(explored: Collection<T>): T? = asSequence()
+        .filter { (node, _) -> node !in explored }
+        .minBy { (_, cost) -> cost }
+        ?.key
+
+/**
+ * Build path from root to target node.
+ */
+private fun <T> pathToNode(target: T, parents: Map<T, T>): List<T> {
+    if (target !in parents) return emptyList()
+
+    val path = mutableListOf<T>()
+    var node: T? = target
+    while (node != null) {
+        path.add(node)
+        node = parents[node]
+    }
+    return path.reversed()
+}
+
+
+fun main() {
+
+    val waypoints: Graph<String> = mapOf(
+            "Start" to mapOf("A" to 5.0),
+            "A" to mapOf("B" to 4.0, "C" to 7.0),
+            "B" to mapOf("Finish" to 4.0),
+            "C" to mapOf("Finish" to 3.0)
+    )
+
+    println(
+            waypoints.dijkstra("Start", "Finish")
+    )
+}