BFS Added tests for shortest path

Chris Pilcher · Chris Pilcher · commit b6ab5205d84e · 2016-02-29T23:46:07.000+13:00
diff --git a/Breadth-First Search/BreadthFirstSearch.playground/Pages/Shortest path example.xcplaygroundpage/Contents.swift b/Breadth-First Search/BreadthFirstSearch.playground/Pages/Shortest path example.xcplaygroundpage/Contents.swift
@@ -1,7 +1,10 @@
-func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
+func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
+  let shortestPathGraph = graph.duplicate()
+
   var queue = Queue<Node>()
-  queue.enqueue(source)
-  source.distance = 0
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
+  queue.enqueue(sourceInShortestPathsGraph)
+  sourceInShortestPathsGraph.distance = 0
 
   while !queue.isEmpty {
     let current = queue.dequeue()!
@@ -14,9 +17,8 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
     }
   }
 
-  print(graph.nodes)
+  return shortestPathGraph
 }
-
 /*:
 ![Animated example of a breadth-first search](Animated_BFS.gif)
 */
@@ -40,4 +42,5 @@ graph.addEdge(nodeC, neighbor: nodeF)
 graph.addEdge(nodeC, neighbor: nodeG)
 graph.addEdge(nodeE, neighbor: nodeH)
 
-breadthFirstSearchShortestPath(graph, source: nodeA)
+let shortestPathGraph = breadthFirstSearchShortestPath(graph, source: nodeA)
+print(shortestPathGraph.nodes)
diff --git a/Breadth-First Search/BreadthFirstSearchShortestPath.swift b/Breadth-First Search/BreadthFirstSearchShortestPath.swift
@@ -1,7 +1,10 @@
-func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
+func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
+  let shortestPathGraph = graph.duplicate()
+
   var queue = Queue<Node>()
-  queue.enqueue(source)
-  source.distance = 0
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
+  queue.enqueue(sourceInShortestPathsGraph)
+  sourceInShortestPathsGraph.distance = 0
 
   while !queue.isEmpty {
     let current = queue.dequeue()!
@@ -14,5 +17,5 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
     }
   }
 
-  print(graph.nodes)
+  return shortestPathGraph
 }
diff --git a/Breadth-First Search/README.markdown b/Breadth-First Search/README.markdown
@@ -145,10 +145,13 @@ Continue until the queue is empty to calculate the shortest path to all other no
 
 Here's the code:
 ```swift
-func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
+func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
+  let shortestPathGraph = graph.duplicate()
+
   var queue = Queue<Node>()
-  queue.enqueue(source)
-  source.distance = 0
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
+  queue.enqueue(sourceInShortestPathsGraph)
+  sourceInShortestPathsGraph.distance = 0
 
   while !queue.isEmpty {
     let current = queue.dequeue()!
@@ -161,13 +164,14 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
     }
   }
 
-  print(graph.nodes)
+  return shortestPathGraph
 }
 ```
 
 Put this code in a playground and test it like so:
 ```swift
-breadthFirstSearchShortestPath(graph, source: nodeA)
+let shortestPathGraph = breadthFirstSearchShortestPath(graph, source: nodeA)
+print(shortestPathGraph.nodes)
 
 // This will output:
 // Node(label: a, distance: 0), Node(label: b, distance: 1), Node(label: c, distance: 1),
diff --git a/Breadth-First Search/Tests/BreadthFirstSearchShortestPathTests.swift b/Breadth-First Search/Tests/BreadthFirstSearchShortestPathTests.swift
@@ -0,0 +1,89 @@
+import XCTest
+
+class BreadthFirstSearchShortestPathTests: XCTestCase {
+
+  func testShortestPathWhenGivenTree() {
+    let tree = Graph()
+    let nodeA = tree.addNode("a")
+    let nodeB = tree.addNode("b")
+    let nodeC = tree.addNode("c")
+    let nodeD = tree.addNode("d")
+    let nodeE = tree.addNode("e")
+    let nodeF = tree.addNode("f")
+    let nodeG = tree.addNode("g")
+    let nodeH = tree.addNode("h")
+    tree.addEdge(nodeA, neighbor: nodeB)
+    tree.addEdge(nodeA, neighbor: nodeC)
+    tree.addEdge(nodeB, neighbor: nodeD)
+    tree.addEdge(nodeB, neighbor: nodeE)
+    tree.addEdge(nodeC, neighbor: nodeF)
+    tree.addEdge(nodeC, neighbor: nodeG)
+    tree.addEdge(nodeE, neighbor: nodeH)
+
+    let shortestPaths = breadthFirstSearchShortestPath(tree, source: nodeA)
+
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeA.label).distance, 0)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeB.label).distance, 1)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeC.label).distance, 1)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeD.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeE.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeF.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeG.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeH.label).distance, 3)
+  }
+
+  func testShortestPathWhenGivenGraph() {
+    let graph = Graph()
+
+    let nodeA = graph.addNode("a")
+    let nodeB = graph.addNode("b")
+    let nodeC = graph.addNode("c")
+    let nodeD = graph.addNode("d")
+    let nodeE = graph.addNode("e")
+    let nodeF = graph.addNode("f")
+    let nodeG = graph.addNode("g")
+    let nodeH = graph.addNode("h")
+    let nodeI = graph.addNode("i")
+
+    graph.addEdge(nodeA, neighbor: nodeB)
+    graph.addEdge(nodeA, neighbor: nodeH)
+    graph.addEdge(nodeB, neighbor: nodeA)
+    graph.addEdge(nodeB, neighbor: nodeC)
+    graph.addEdge(nodeB, neighbor: nodeH)
+    graph.addEdge(nodeC, neighbor: nodeB)
+    graph.addEdge(nodeC, neighbor: nodeD)
+    graph.addEdge(nodeC, neighbor: nodeF)
+    graph.addEdge(nodeC, neighbor: nodeI)
+    graph.addEdge(nodeD, neighbor: nodeC)
+    graph.addEdge(nodeD, neighbor: nodeE)
+    graph.addEdge(nodeD, neighbor: nodeF)
+    graph.addEdge(nodeE, neighbor: nodeD)
+    graph.addEdge(nodeE, neighbor: nodeF)
+    graph.addEdge(nodeF, neighbor: nodeC)
+    graph.addEdge(nodeF, neighbor: nodeD)
+    graph.addEdge(nodeF, neighbor: nodeE)
+    graph.addEdge(nodeF, neighbor: nodeG)
+    graph.addEdge(nodeG, neighbor: nodeF)
+    graph.addEdge(nodeG, neighbor: nodeH)
+    graph.addEdge(nodeG, neighbor: nodeI)
+    graph.addEdge(nodeH, neighbor: nodeA)
+    graph.addEdge(nodeH, neighbor: nodeB)
+    graph.addEdge(nodeH, neighbor: nodeG)
+    graph.addEdge(nodeH, neighbor: nodeI)
+    graph.addEdge(nodeI, neighbor: nodeC)
+    graph.addEdge(nodeI, neighbor: nodeG)
+    graph.addEdge(nodeI, neighbor: nodeH)
+
+    let shortestPaths = breadthFirstSearchShortestPath(graph, source: nodeA)
+
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeA.label).distance, 0)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeB.label).distance, 1)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeC.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeD.label).distance, 3)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeE.label).distance, 4)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeF.label).distance, 3)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeG.label).distance, 2)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeH.label).distance, 1)
+    XCTAssertEqual(shortestPaths.findNodeWithLabel(nodeI.label).distance, 2)
+  }
+}
diff --git a/Breadth-First Search/Tests/Tests.xcodeproj/project.pbxproj b/Breadth-First Search/Tests/Tests.xcodeproj/project.pbxproj
@@ -8,6 +8,7 @@
 
 /* Begin PBXBuildFile section */
 		83AACB421C844CED00DDAFC7 /* BreadthFirstSearchMinimumSpanningTreeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83AACB411C844CED00DDAFC7 /* BreadthFirstSearchMinimumSpanningTreeTests.swift */; };
+		83AACB441C8456D200DDAFC7 /* BreadthFirstSearchShortestPathTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83AACB431C8456D200DDAFC7 /* BreadthFirstSearchShortestPathTests.swift */; };
 		83F9C9681C84437C00B3A87F /* BreadthFirstSearch.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83F9C9651C84437C00B3A87F /* BreadthFirstSearch.swift */; };
 		83F9C9691C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83F9C9661C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift */; };
 		83F9C96A1C84437C00B3A87F /* BreadthFirstSearchShortestPath.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83F9C9671C84437C00B3A87F /* BreadthFirstSearchShortestPath.swift */; };
@@ -22,6 +23,7 @@
 		7B2BBC801C779D720067B71D /* Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = Tests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		7B2BBC941C779E7B0067B71D /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = SOURCE_ROOT; };
 		83AACB411C844CED00DDAFC7 /* BreadthFirstSearchMinimumSpanningTreeTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BreadthFirstSearchMinimumSpanningTreeTests.swift; sourceTree = SOURCE_ROOT; };
+		83AACB431C8456D200DDAFC7 /* BreadthFirstSearchShortestPathTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BreadthFirstSearchShortestPathTests.swift; sourceTree = SOURCE_ROOT; };
 		83F9C9651C84437C00B3A87F /* BreadthFirstSearch.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = BreadthFirstSearch.swift; path = ../BreadthFirstSearch.swift; sourceTree = SOURCE_ROOT; };
 		83F9C9661C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = BreadthFirstSearchMinimumSpanningTree.swift; path = ../BreadthFirstSearchMinimumSpanningTree.swift; sourceTree = SOURCE_ROOT; };
 		83F9C9671C84437C00B3A87F /* BreadthFirstSearchShortestPath.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = BreadthFirstSearchShortestPath.swift; path = ../BreadthFirstSearchShortestPath.swift; sourceTree = SOURCE_ROOT; };
@@ -66,12 +68,13 @@
 				83F9C96E1C84449D00B3A87F /* Graph.swift */,
 				83F9C96F1C84449D00B3A87F /* Node.swift */,
 				83F9C9701C84449D00B3A87F /* Queue.swift */,
-				83F9C96B1C8443E800B3A87F /* BreadthFirstSearchTests.swift */,
 				83F9C9651C84437C00B3A87F /* BreadthFirstSearch.swift */,
-				83F9C9661C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift */,
 				83F9C9671C84437C00B3A87F /* BreadthFirstSearchShortestPath.swift */,
-				7B2BBC941C779E7B0067B71D /* Info.plist */,
+				83F9C9661C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift */,
+				83F9C96B1C8443E800B3A87F /* BreadthFirstSearchTests.swift */,
+				83AACB431C8456D200DDAFC7 /* BreadthFirstSearchShortestPathTests.swift */,
 				83AACB411C844CED00DDAFC7 /* BreadthFirstSearchMinimumSpanningTreeTests.swift */,
+				7B2BBC941C779E7B0067B71D /* Info.plist */,
 			);
 			name = Tests;
 			path = TestsTests;
@@ -145,6 +148,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				83AACB441C8456D200DDAFC7 /* BreadthFirstSearchShortestPathTests.swift in Sources */,
 				83AACB421C844CED00DDAFC7 /* BreadthFirstSearchMinimumSpanningTreeTests.swift in Sources */,
 				83F9C9721C84449D00B3A87F /* Graph.swift in Sources */,
 				83F9C9691C84437C00B3A87F /* BreadthFirstSearchMinimumSpanningTree.swift in Sources */,

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,10 @@`
`1`		`-func breadthFirstSearchShortestPath(graph: Graph, source: Node) {`
	`1`	`+func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {`
	`2`	`+ let shortestPathGraph = graph.duplicate()`
	`3`	`+`
`2`	`4`	`var queue = Queue<Node>()`
`3`		`- queue.enqueue(source)`
`4`		`- source.distance = 0`
	`5`	`+ let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)`
	`6`	`+ queue.enqueue(sourceInShortestPathsGraph)`
	`7`	`+ sourceInShortestPathsGraph.distance = 0`
`5`	`8`
`6`	`9`	`while !queue.isEmpty {`
`7`	`10`	`let current = queue.dequeue()!`
`@@ -14,5 +17,5 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) {`
`14`	`17`	`}`
`15`	`18`	`}`
`16`	`19`
`17`		`- print(graph.nodes)`
	`20`	`+ return shortestPathGraph`
`18`	`21`	`}`