Graph traversal

Author: DanielMichalski

src/main/kotlin/pl/dmichalski/algorithms/data_structures/_11_graph_traversal/Node.kt

@@ -0,0 +1,17 @@
+package pl.dmichalski.algorithms.data_structures._11_graph_traversal
+
+data class Node(private val vertex: String, private val connections: MutableList<String>) {
+
+    fun getVertex(): String {
+        return vertex
+    }
+
+    fun getConnections(): MutableList<String> {
+        return connections
+    }
+
+    override fun toString(): String {
+        return "Node(vertex='$vertex', connections=$connections)"
+    }
+
+}

src/main/kotlin/pl/dmichalski/algorithms/data_structures/_11_graph_traversal/Runner.kt

@@ -0,0 +1,67 @@
+package pl.dmichalski.algorithms.data_structures._11_graph_traversal
+
+object Runner {
+
+    private const val VERTEX_A = "A"
+    private const val VERTEX_B = "B"
+    private const val VERTEX_C = "C"
+    private const val VERTEX_D = "D"
+    private const val VERTEX_E = "E"
+    private const val VERTEX_F = "F"
+
+    @JvmStatic
+    fun main(args: Array<String>) {
+        println("------------------ Initial undirected graph ------------------ ")
+        var undirectedGraph = getUndirectedGraph()
+        printUndirectedGraph(undirectedGraph)
+
+        println("------------------ Depth First Search recursive traversal ------------------ ")
+        undirectedGraph = getUndirectedGraph()
+        var depthFirstSearch = undirectedGraph.depthFirstSearchRecursive(VERTEX_A)
+        println("Graph elements: $depthFirstSearch")
+        printUndirectedGraph(undirectedGraph)
+
+        println("------------------ Depth First Search iterative traversal ------------------ ")
+        undirectedGraph = getUndirectedGraph()
+        depthFirstSearch = undirectedGraph.depthFirstSearchIterative(VERTEX_A)
+        println("Graph elements: $depthFirstSearch")
+        printUndirectedGraph(undirectedGraph)
+    }
+
+    /**
+     * It returns undirected graph like this:
+     * <pre>
+     *          A
+     *       /     \
+     *      B       C
+     *      \      /
+     *       D -- E
+     *        \  /
+     *         F
+     * </pre>
+     */
+    private fun getUndirectedGraph(): UndirectedGraph {
+        val undirectedGraph = UndirectedGraph()
+
+        undirectedGraph.addVertex(VERTEX_A)
+        undirectedGraph.addVertex(VERTEX_B)
+        undirectedGraph.addVertex(VERTEX_C)
+        undirectedGraph.addVertex(VERTEX_D)
+        undirectedGraph.addVertex(VERTEX_E)
+        undirectedGraph.addVertex(VERTEX_F)
+
+        undirectedGraph.addEdge(VERTEX_A, VERTEX_B)
+        undirectedGraph.addEdge(VERTEX_A, VERTEX_C)
+        undirectedGraph.addEdge(VERTEX_B, VERTEX_D)
+        undirectedGraph.addEdge(VERTEX_C, VERTEX_E)
+        undirectedGraph.addEdge(VERTEX_D, VERTEX_E)
+        undirectedGraph.addEdge(VERTEX_D, VERTEX_F)
+        undirectedGraph.addEdge(VERTEX_E, VERTEX_F)
+
+        return undirectedGraph
+    }
+
+    private fun printUndirectedGraph(undirectedGraph: UndirectedGraph) {
+        println(undirectedGraph)
+    }
+}

src/main/kotlin/pl/dmichalski/algorithms/data_structures/_11_graph_traversal/UndirectedGraph.kt

@@ -0,0 +1,86 @@
+package pl.dmichalski.algorithms.data_structures._11_graph_traversal
+
+import java.util.*
+import kotlin.collections.ArrayList
+import kotlin.collections.HashSet
+
+class UndirectedGraph {
+
+    private val adjacencyList: MutableList<Node> = ArrayList()
+
+    fun addVertex(vertex: String) {
+        val node = findNode(vertex)
+
+        if (node == null) {
+            val newNode = Node(vertex, mutableListOf())
+            this.adjacencyList.add(newNode)
+        }
+    }
+
+    fun addEdge(vertex1: String, vertex2: String) {
+        val node1 = findNode(vertex1)
+        val node2 = findNode(vertex2)
+
+        node1!!.getConnections().add(vertex2)
+        node2!!.getConnections().add(vertex1)
+    }
+
+    fun depthFirstSearchRecursive(vertex: String): MutableList<Node> {
+        val result: MutableList<Node> = ArrayList()
+        val visited: MutableSet<String> = HashSet()
+
+        val node = findNode(vertex)
+
+        fun dfs(node: Node?) {
+            if (node == null) {
+                return
+            }
+            visited.add(node.getVertex())
+            result.add(node)
+            node.getConnections()
+                    .map { con -> findNode(con) }
+                    .filter { neighbour -> !visited.contains(neighbour!!.getVertex()) }
+                    .forEach { neighbour -> dfs(neighbour) }
+        }
+
+        dfs(node)
+
+        return result
+    }
+
+    fun depthFirstSearchIterative(vertex: String): MutableList<Node> {
+        val stack = ArrayDeque<Node>()
+        stack.push(findNode(vertex)!!)
+        val result: MutableList<Node> = ArrayList()
+        val visited: MutableSet<String> = HashSet()
+        var currentVertex: Node?
+
+        visited.add(vertex)
+        while (stack.size > 0) {
+            currentVertex = stack.pop()
+            result.add(currentVertex)
+
+            currentVertex.getConnections()
+                    .map { con -> findNode(con) }
+                    .filter { neighbour -> !visited.contains(neighbour!!.getVertex()) }
+                    .forEach { neighbour ->
+                        visited.add(neighbour!!.getVertex())
+                        stack.push(neighbour)
+                    }
+        }
+
+        return result
+    }
+
+    override fun toString(): String {
+        return "UndirectedGraph(adjacencyList='$adjacencyList')\n"
+    }
+
+    private fun findNode(vertex: String): Node? {
+        return adjacencyList.stream()
+                .filter { node -> node.getVertex() == vertex }
+                .findFirst()
+                .orElse(null)
+    }
+
+}