Fix error in depth-first search

Results were added in the wrong order inside the DFS too.
Unit tests now use a function to check whether the result is a valid topological sort.

Author: hollance

Topological Sort/README.markdown

@@ -28,15 +28,15 @@ If we were to represent these objectives in the form of a graph it would look as
 
 ![Example](Images/Algorithms.png)
 
-If we consider each algorithm to be a vertex in the graph you can clearly see the dependencies between them. To learn something you might have to know something else first. This is exactly what topological sort is used for -- it will sort things out such that you know what to do first.
+If we consider each algorithm to be a vertex in the graph you can clearly see the dependencies between them. To learn something you might have to know something else first. This is exactly what topological sort is used for -- it will sort things out so that you know what to do first.
 
 ## How does it work?
 
 **Step 1: Find all vertices that have in-degree of 0**
 
 The *in-degree* of a vertex is the number of edges pointing at that vertex. Vertices with no incoming edges have an in-degree of 0. These vertices are the starting points for the topological sort.
 
-In the context of the previous example, these vertices represent algorithms that don't have any prerequisites; you don't need to learn anything else first, hence the sort starts with them.
+In the context of the previous example, these starting vertices represent algorithms and data structures that don't have any prerequisites; you don't need to learn anything else first, hence the sort starts with them.
 
 **Step 2: Traverse the graph with depth-first search**
 
@@ -63,20 +63,20 @@ Consider the following graph:
 **Step 2:** Perform depth-first search for each starting vertex, without remembering vertices that have already been visited:
 
 ```
-Vertex 3: 3, 8, 9, 10
+Vertex 3: 3, 10, 8, 9
 Vertex 7: 7, 11, 2, 8, 9
 Vertex 5: 5, 11, 2, 9, 10
 ```
 
 **Step 3:** Filter out the vertices already visited in each previous search:
 
 ```
-Vertex 3: 3, 8, 9, 10
+Vertex 3: 3, 10, 8, 9
 Vertex 7: 7, 11, 2
 Vertex 5: 5
 ```
 
-**Step 4:** Combine the results of these three depth-first searches. The final sorted order is **5, 7, 11, 2, 3, 8, 9, 10**. (Important: we need to add the results of each subsequent search to the *front* of the list.)
+**Step 4:** Combine the results of these three depth-first searches. The final sorted order is **5, 7, 11, 2, 3, 10, 8, 9**. (Important: we need to add the results of each subsequent search to the *front* of the sorted list.)
 
 The result of the topological sort looks like this:
 
@@ -122,11 +122,13 @@ Some remarks:
 
 2. The `visited` array keeps track of whether we've already seen a vertex during the depth-first search. Initially, we set all elements to `false`.
 
-3. For each of the vertices in the `startNodes` array, perform a depth-first search. This returns an array of `Node` objects. We prepend that array to our own `result` array.
+3. For each of the vertices in the `startNodes` array, perform a depth-first search. This returns an array of sorted `Node` objects. We prepend that array to our own `result` array.
 
 4. The `result` array contains all the vertices in topologically sorted order.
 
-## Alternative method (Kahn's algorithm)
+> **Note:** For a slightly different implementation of topological sort using depth-first search, see [TopologicalSort3.swift](TopologicalSort3.swift). This uses a stack and does not require you to find all vertices with in-degree 0 first.
+
+## Kahn's algorithm
 
 Even though depth-first search is the typical way to perform a topological sort, there is another algorithm that also does the job. 
 

Topological Sort/Tests/TopologicalSortTests.swift

@@ -18,6 +18,18 @@ extension Graph {
 
 class TopologicalSort: XCTestCase {
 
+  // The topological sort is valid if a node does not have any of its
+  // predecessors in its adjacency list.
+  func checkIsValidTopologicalSort(graph: Graph, _ a: [Graph.Node]) {
+    for i in (a.count - 1).stride(to: 0, by: -1) {
+      if let neighbors = graph.adjacencyList(forNode: a[i]) {
+        for j in (i - 1).stride(through: 0, by: -1) {
+          XCTAssertFalse(neighbors.contains(a[j]), "\(a) is not a valid topological sort")
+        }
+      }
+    }
+  }
+  
   func testTopologicalSort() {
     let graph = Graph()
 
@@ -40,51 +52,31 @@ class TopologicalSort: XCTestCase {
     graph.addEdge(fromNode: node11, toNode: node10)
     graph.addEdge(fromNode: node8, toNode: node9)
 
-    XCTAssertEqual(graph.topologicalSort(), ["5", "7", "11", "2", "3", "8", "9", "10"])
+    XCTAssertEqual(graph.topologicalSort(), ["5", "7", "11", "2", "3", "10", "8", "9"])
     XCTAssertEqual(graph.topologicalSortKahn(), ["3", "7", "5", "8", "11", "2", "9", "10"])
     XCTAssertEqual(graph.topologicalSortAlternative(), ["5", "7", "3", "8", "11", "10", "9", "2"])
   }
 
   func testTopologicalSortEdgeLists() {
     let p1 = ["A B", "A C", "B C", "B D", "C E", "C F", "E D", "F E", "G A", "G F"]
-    let s1 = ["G", "A", "B", "C", "E", "D", "F"]
-    let a1 = ["G", "A", "B", "C", "F", "E", "D"]
-    let k1 = ["G", "A", "B", "C", "F", "E", "D"]
-
     let p2 = ["B C", "C D", "C G", "B F", "D G", "G E", "F G", "F G"]
-    let s2 = ["B", "C", "D", "G", "E", "F"]
-    let a2 = ["B", "C", "F", "D", "G", "E"]
-    let k2 = ["B", "F", "C", "D", "G", "E"]
-
     let p3 = ["S V", "S W", "V T", "W T"]
-    let s3 = ["S", "V", "W", "T"]
-    let a3 = ["S", "V", "W", "T"]
-    let k3 = ["S", "V", "W", "T"]
-
     let p4 = ["5 11", "7 11", "7 8", "3 8", "3 10", "11 2", "11 9", "11 10", "8 9"]
-    let s4 = ["5", "7", "11", "2", "3", "8", "9", "10"]
-    let a4 = ["3", "7", "5", "8", "11", "2", "9", "10"]
-    let k4 = ["5", "7", "3", "8", "11", "10", "9", "2"]
 
-    let data = [
-      (p1, s1, a1, k1),
-      (p2, s2, a2, k2),
-      (p3, s3, a3, k3),
-      (p4, s4, a4, k4),
-    ]
+    let data = [ p1, p2, p3, p4 ]
 
     for d in data {
       let graph = Graph()
-      graph.loadEdgeList(d.0)
+      graph.loadEdgeList(d)
 
       let sorted1 = graph.topologicalSort()
-      XCTAssertEqual(sorted1, d.1)
+      checkIsValidTopologicalSort(graph, sorted1)
 
       let sorted2 = graph.topologicalSortKahn()
-      XCTAssertEqual(sorted2, d.2)
+      checkIsValidTopologicalSort(graph, sorted2)
 
       let sorted3 = graph.topologicalSortAlternative()
-      XCTAssertEqual(sorted3, d.3)
+      checkIsValidTopologicalSort(graph, sorted3)
     }
   }
 }

Topological Sort/Topological Sort.playground/Sources/TopologicalSort1.swift

@@ -1,18 +1,19 @@
 extension Graph {
   private func depthFirstSearch(source: Node, inout visited: [Node : Bool]) -> [Node] {
-    var result = [source]
-    visited[source] = true
+    var result = [Node]()
 
     if let adjacencyList = adjacencyList(forNode: source) {
       for nodeInAdjacencyList in adjacencyList {
         if let seen = visited[nodeInAdjacencyList] where !seen {
-          result += depthFirstSearch(nodeInAdjacencyList, visited: &visited)
+          result = depthFirstSearch(nodeInAdjacencyList, visited: &visited) + result
         }
       }
     }
-    return result
+    
+    visited[source] = true
+    return [source] + result
   }
-  
+
   /* Topological sort using depth-first search. */
   public func topologicalSort() -> [Node] {
 

Topological Sort/TopologicalSort1.swift

@@ -1,16 +1,17 @@
 extension Graph {
   private func depthFirstSearch(source: Node, inout visited: [Node : Bool]) -> [Node] {
-    var result = [source]
-    visited[source] = true
+    var result = [Node]()
 
     if let adjacencyList = adjacencyList(forNode: source) {
       for nodeInAdjacencyList in adjacencyList {
         if let seen = visited[nodeInAdjacencyList] where !seen {
-          result += depthFirstSearch(nodeInAdjacencyList, visited: &visited)
+          result = depthFirstSearch(nodeInAdjacencyList, visited: &visited) + result
         }
       }
     }
-    return result
+    
+    visited[source] = true
+    return [source] + result
   }
 
   /* Topological sort using depth-first search. */