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

Add breadth-first search

Author: hollance

Breadth-First Search/BreadthFirstSearch.playground/Pages/Minimum spanning tree example.xcplaygroundpage/Contents.swift

@@ -0,0 +1,71 @@
+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
+}
+
+/*:
+![Animated example of a breadth-first search](Minimum_Spanning_Tree.png)
+*/
+
+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 minimumSpanningTree = breadthFirstSearchMinimumSpanningTree(graph, source: nodeA)
+print(minimumSpanningTree)

Breadth-First Search/BreadthFirstSearch.playground/Pages/Minimum spanning tree example.xcplaygroundpage/timeline.xctimeline

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>

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

@@ -0,0 +1,43 @@
+func breadthFirstSearchShortestPath(graph: Graph, source: Node) {
+  var queue = Queue<Node>()
+  queue.enqueue(source)
+  source.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
+      }
+    }
+  }
+
+  print(graph.nodes)
+}
+
+/*:
+![Animated example of a breadth-first search](Animated_BFS.gif)
+*/
+
+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")
+
+graph.addEdge(nodeA, neighbor: nodeB)
+graph.addEdge(nodeA, neighbor: nodeC)
+graph.addEdge(nodeB, neighbor: nodeD)
+graph.addEdge(nodeB, neighbor: nodeE)
+graph.addEdge(nodeC, neighbor: nodeF)
+graph.addEdge(nodeC, neighbor: nodeG)
+graph.addEdge(nodeE, neighbor: nodeH)
+
+breadthFirstSearchShortestPath(graph, source: nodeA)

Breadth-First Search/BreadthFirstSearch.playground/Pages/Shortest path example.xcplaygroundpage/timeline.xctimeline

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>

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

@@ -0,0 +1,45 @@
+func breadthFirstSearch(graph: Graph, source: Node) {
+  var seenNodes = [source]
+  var queue = Queue<Node>()
+  queue.enqueue(source)
+
+  print(source.label)
+
+  while !queue.isEmpty {
+    let current = queue.dequeue()!
+    for edge in current.neighbors {
+      let neighborNode = edge.neighbor
+      if !seenNodes.contains(neighborNode) {
+        queue.enqueue(neighborNode)
+        seenNodes.append(neighborNode)
+        print(neighborNode.label)
+      }
+    }
+  }
+}
+
+/*:
+![Animated example of a breadth-first search](Animated_BFS.gif)
+*/
+
+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")
+
+graph.addEdge(nodeA, neighbor: nodeB)
+graph.addEdge(nodeA, neighbor: nodeC)
+graph.addEdge(nodeB, neighbor: nodeD)
+graph.addEdge(nodeB, neighbor: nodeE)
+graph.addEdge(nodeC, neighbor: nodeF)
+graph.addEdge(nodeC, neighbor: nodeG)
+graph.addEdge(nodeE, neighbor: nodeH)
+
+
+breadthFirstSearch(graph, source: nodeA)

Breadth-First Search/BreadthFirstSearch.playground/Pages/Simple example.xcplaygroundpage/timeline.xctimeline

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>

Breadth-First Search/BreadthFirstSearch.playground/Resources/Animated_BFS.gif

@@ -0,0 +1,7 @@
+public class Edge {
+  public var neighbor: Node
+
+  public init(neighbor: Node) {
+    self.neighbor = neighbor
+  }
+}

Breadth-First Search/BreadthFirstSearch.playground/Resources/Minimum_Spanning_Tree.png

@@ -0,0 +1,52 @@
+public class Graph : CustomStringConvertible {
+  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
+  }
+}