Merge pull request kodecocodes#58 from chris-pilcher/breadth-first-search-tests

Breadth first search tests

Author: hollance

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)

Breadth-First Search/BreadthFirstSearch.playground/Pages/Simple example.xcplaygroundpage/Contents.swift

@@ -1,21 +1,24 @@
-func breadthFirstSearch(graph: Graph, source: Node) {
-  var seenNodes = [source]
+func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
   var queue = Queue<Node>()
   queue.enqueue(source)
 
-  print(source.label)
+  var nodesExplored = [source.label]
+  source.visited = true
 
   while !queue.isEmpty {
     let current = queue.dequeue()!
     for edge in current.neighbors {
       let neighborNode = edge.neighbor
-      if !seenNodes.contains(neighborNode) {
+      if !neighborNode.visited {
         queue.enqueue(neighborNode)
-        seenNodes.append(neighborNode)
-        print(neighborNode.label)
+        neighborNode.visited = true
+
+        nodesExplored.append(neighborNode.label)
       }
     }
   }
+
+  return nodesExplored
 }
 
 /*:
@@ -42,4 +45,5 @@ graph.addEdge(nodeC, neighbor: nodeG)
 graph.addEdge(nodeE, neighbor: nodeH)
 
 
-breadthFirstSearch(graph, source: nodeA)
+let nodesExplored = breadthFirstSearch(graph, source: nodeA)
+print(nodesExplored)

Breadth-First Search/BreadthFirstSearch.playground/Sources/Edge.swift

@@ -1,7 +1,11 @@
-public class Edge {
+public class Edge : Equatable {
   public var neighbor: Node
 
   public init(neighbor: Node) {
     self.neighbor = neighbor
   }
 }
+
+public func ==(lhs: Edge, rhs: Edge) -> Bool {
+  return lhs.neighbor == rhs.neighbor
+}

Breadth-First Search/BreadthFirstSearch.playground/Sources/Graph.swift

@@ -1,4 +1,4 @@
-public class Graph : CustomStringConvertible {
+public class Graph : CustomStringConvertible, Equatable {
   public private(set) var nodes: [Node]
 
   public init() {
@@ -50,3 +50,7 @@ public class Graph : CustomStringConvertible {
     return duplicated
   }
 }
+
+public func ==(lhs: Graph, rhs: Graph) -> Bool {
+  return lhs.nodes == rhs.nodes
+}

Breadth-First Search/BreadthFirstSearch.playground/Sources/Node.swift

@@ -1,6 +1,6 @@
 public class Node : CustomStringConvertible, Equatable {
   public var neighbors: [Edge]
-  
+
   public private(set) var label: String
   public var distance: Int?
   public var visited: Bool
@@ -28,5 +28,5 @@ public class Node : CustomStringConvertible, Equatable {
 }
 
 public func ==(lhs: Node, rhs: Node) -> Bool {
-  return lhs.label == rhs.label
+  return lhs.label == rhs.label && lhs.neighbors == rhs.neighbors
 }

Breadth-First Search/BreadthFirstSearch.swift

@@ -0,0 +1,22 @@
+func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
+  var queue = Queue<Node>()
+  queue.enqueue(source)
+
+  var nodesExplored = [source.label]
+  source.visited = true
+  
+  while !queue.isEmpty {
+    let current = queue.dequeue()!
+    for edge in current.neighbors {
+      let neighborNode = edge.neighbor
+      if !neighborNode.visited {
+        queue.enqueue(neighborNode)
+        neighborNode.visited = true
+
+        nodesExplored.append(neighborNode.label)
+      }
+    }
+  }
+
+  return nodesExplored
+}

Breadth-First Search/BreadthFirstSearchMinimumSpanningTree.swift

@@ -0,0 +1,23 @@
+func breadthFirstSearchMinimumSpanningTree(graph: Graph, source: Node) -> Graph {
+  let minimumSpanningTree = graph.duplicate()
+
+  var queue = Queue<Node>()
+  let sourceInMinimumSpanningTree = minimumSpanningTree.findNodeWithLabel(source.label)
+  queue.enqueue(sourceInMinimumSpanningTree)
+  sourceInMinimumSpanningTree.visited = true
+
+  while !queue.isEmpty {
+    let current = queue.dequeue()!
+    for edge in current.neighbors {
+      let neighborNode = edge.neighbor
+      if !neighborNode.visited {
+        neighborNode.visited = true
+        queue.enqueue(neighborNode)
+      } else {
+        current.remove(edge)
+      }
+    }
+  }
+
+  return minimumSpanningTree
+}

Breadth-First Search/BreadthFirstSearchShortestPath.swift

@@ -0,0 +1,21 @@
+func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
+  let shortestPathGraph = graph.duplicate()
+
+  var queue = Queue<Node>()
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
+  queue.enqueue(sourceInShortestPathsGraph)
+  sourceInShortestPathsGraph.distance = 0
+
+  while !queue.isEmpty {
+    let current = queue.dequeue()!
+    for edge in current.neighbors {
+      let neighborNode = edge.neighbor
+      if !neighborNode.hasDistance {
+        queue.enqueue(neighborNode)
+        neighborNode.distance = current.distance! + 1
+      }
+    }
+  }
+
+  return shortestPathGraph
+}

Breadth-First Search/Edge.swift

@@ -0,0 +1,11 @@
+public class Edge : Equatable {
+  public var neighbor: Node
+
+  public init(neighbor: Node) {
+    self.neighbor = neighbor
+  }
+}
+
+public func ==(lhs: Edge, rhs: Edge) -> Bool {
+  return lhs.neighbor == rhs.neighbor
+}

Breadth-First Search/Graph.swift

@@ -0,0 +1,56 @@
+public class Graph : CustomStringConvertible, Equatable {
+  public private(set) var nodes: [Node]
+
+  public init() {
+    self.nodes = []
+  }
+
+  public func addNode(label: String) -> Node {
+    let node = Node(label: label)
+    nodes.append(node)
+    return node
+  }
+
+  public func addEdge(source: Node, neighbor: Node) {
+    let edge = Edge(neighbor: neighbor)
+    edge.neighbor = neighbor
+    source.neighbors.append(edge)
+  }
+
+  public var description: String {
+    var description = ""
+
+    for node in nodes {
+      if !node.neighbors.isEmpty {
+        description += "[node: \(node.label) edges: \(node.neighbors.map{ $0.neighbor.label})]"
+      }
+    }
+    return description
+  }
+
+  public func findNodeWithLabel(label: String) -> Node {
+    return nodes.filter{ $0.label == label }.first!
+  }
+
+  public func duplicate() -> Graph {
+    let duplicated = Graph()
+
+    for node in nodes {
+      duplicated.addNode(node.label)
+    }
+
+    for node in nodes {
+      for edge in node.neighbors {
+        let source = duplicated.findNodeWithLabel(node.label)
+        let neighbour = duplicated.findNodeWithLabel(edge.neighbor.label)
+        duplicated.addEdge(source, neighbor: neighbour)
+      }
+    }
+
+    return duplicated
+  }
+}
+
+public func ==(lhs: Graph, rhs: Graph) -> Bool {
+  return lhs.nodes == rhs.nodes
+}