Merge pull request kodecocodes#343 from gonini/master

Updating Shortest Path (Unweighted) to Swift 3

Author: kelvinlauKL

.travis.yml

@@ -37,7 +37,7 @@ script:
 # - xcodebuild test -project ./Select\ Minimum\ Maximum/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Selection\ Sort/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Shell\ Sort/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Shortest\ Path\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Shortest\ Path\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Single-Source\ Shortest\ Paths\ \(Weighted\)/SSSP.xcodeproj -scheme SSSPTests
 - xcodebuild test -project ./Stack/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Topological\ Sort/Tests/Tests.xcodeproj -scheme Tests

Shortest Path (Unweighted)/README.markdown

@@ -23,37 +23,37 @@ The root of the tree is the node you started the breadth-first search from. To f
 Let's put breadth-first search into practice and calculate the shortest path from `A` to all the other nodes. We start with the source node `A` and add it to a queue with a distance of `0`.
 
 ```swift
-queue.enqueue(A)
+queue.enqueue(element: A)
 A.distance = 0
 ```
 
 The queue is now `[ A ]`. We dequeue `A` and enqueue its two immediate neighbor nodes `B` and `C` with a distance of `1`.
 
 ```swift
 queue.dequeue()   // A
-queue.enqueue(B)
+queue.enqueue(element: B)
 B.distance = A.distance + 1   // result: 1
-queue.enqueue(C)
+queue.enqueue(element: C)
 C.distance = A.distance + 1   // result: 1
 ```
 
 The queue is now `[ B, C ]`. Dequeue `B` and enqueue `B`'s neighbor nodes `D` and `E` with a distance of `2`.
 
 ```swift
 queue.dequeue()   // B
-queue.enqueue(D)
+queue.enqueue(element: D)
 D.distance = B.distance + 1   // result: 2
-queue.enqueue(E)
+queue.enqueue(element: E)
 E.distance = B.distance + 1   // result: 2
 ```
 
 The queue is now `[ C, D, E ]`. Dequeue `C` and enqueue `C`'s neighbor nodes `F` and `G`, also with a distance of `2`.
 
 ```swift
 queue.dequeue()   // C
-queue.enqueue(F)
+queue.enqueue(element: F)
 F.distance = C.distance + 1   // result: 2
-queue.enqueue(G)
+queue.enqueue(element: G)
 G.distance = C.distance + 1   // result: 2
 ```
 
@@ -66,15 +66,15 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
   let shortestPathGraph = graph.duplicate()
 
   var queue = Queue<Node>()
-  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
-  queue.enqueue(sourceInShortestPathsGraph)
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(label: source.label)
+  queue.enqueue(element: sourceInShortestPathsGraph)
   sourceInShortestPathsGraph.distance = 0
 
   while let current = queue.dequeue() {
     for edge in current.neighbors {
       let neighborNode = edge.neighbor
       if !neighborNode.hasDistance {
-        queue.enqueue(neighborNode)
+        queue.enqueue(element: neighborNode)
         neighborNode.distance = current.distance! + 1
       }
     }
@@ -87,7 +87,7 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
 Put this code in a playground and test it like so:
 
 ```swift
-let shortestPathGraph = breadthFirstSearchShortestPath(graph, source: nodeA)
+let shortestPathGraph = breadthFirstSearchShortestPath(graph: graph, source: nodeA)
 print(shortestPathGraph.nodes)
 ```
 

Shortest Path (Unweighted)/ShortestPath.playground/Pages/Shortest path example.xcplaygroundpage/Contents.swift

@@ -2,15 +2,15 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
   let shortestPathGraph = graph.duplicate()
 
   var queue = Queue<Node>()
-  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(source.label)
-  queue.enqueue(sourceInShortestPathsGraph)
+  let sourceInShortestPathsGraph = shortestPathGraph.findNodeWithLabel(label: source.label)
+  queue.enqueue(element: sourceInShortestPathsGraph)
   sourceInShortestPathsGraph.distance = 0
 
   while let current = queue.dequeue() {
     for edge in current.neighbors {
       let neighborNode = edge.neighbor
       if !neighborNode.hasDistance {
-        queue.enqueue(neighborNode)
+        queue.enqueue(element: neighborNode)
         neighborNode.distance = current.distance! + 1
       }
     }
@@ -23,14 +23,14 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
 
 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 nodeA = graph.addNode(label: "a")
+let nodeB = graph.addNode(label: "b")
+let nodeC = graph.addNode(label: "c")
+let nodeD = graph.addNode(label: "d")
+let nodeE = graph.addNode(label: "e")
+let nodeF = graph.addNode(label: "f")
+let nodeG = graph.addNode(label: "g")
+let nodeH = graph.addNode(label: "h")
 
 graph.addEdge(nodeA, neighbor: nodeB)
 graph.addEdge(nodeA, neighbor: nodeC)
@@ -40,5 +40,5 @@ graph.addEdge(nodeC, neighbor: nodeF)
 graph.addEdge(nodeC, neighbor: nodeG)
 graph.addEdge(nodeE, neighbor: nodeH)
 
-let shortestPathGraph = breadthFirstSearchShortestPath(graph, source: nodeA)
+let shortestPathGraph = breadthFirstSearchShortestPath(graph: graph, source: nodeA)
 print(shortestPathGraph.nodes)

Shortest Path (Unweighted)/ShortestPath.playground/Pages/Shortest path example.xcplaygroundpage/timeline.xctimeline

@@ -11,7 +11,7 @@ public class Graph: CustomStringConvertible, Equatable {
     return node
   }
 
-  public func addEdge(source: Node, neighbor: Node) {
+  public func addEdge(_ source: Node, neighbor: Node) {
     let edge = Edge(neighbor: neighbor)
     source.neighbors.append(edge)
   }
@@ -35,13 +35,13 @@ public class Graph: CustomStringConvertible, Equatable {
     let duplicated = Graph()
 
     for node in nodes {
-      duplicated.addNode(node.label)
+      duplicated.addNode(label: node.label)
     }
 
     for node in nodes {
       for edge in node.neighbors {
-        let source = duplicated.findNodeWithLabel(node.label)
-        let neighbour = duplicated.findNodeWithLabel(edge.neighbor.label)
+        let source = duplicated.findNodeWithLabel(label: node.label)
+        let neighbour = duplicated.findNodeWithLabel(label: edge.neighbor.label)
         duplicated.addEdge(source, neighbor: neighbour)
       }
     }

Shortest Path (Unweighted)/ShortestPath.playground/Sources/Graph.swift

@@ -23,7 +23,7 @@ public class Node: CustomStringConvertible, Equatable {
   }
 
   public func remove(edge: Edge) {
-    neighbors.removeAtIndex(neighbors.indexOf { $0 === edge }!)
+    neighbors.remove(at: neighbors.index { $0 === edge }!)
   }
 }
 

Shortest Path (Unweighted)/ShortestPath.playground/Sources/Node.swift

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

Shortest Path (Unweighted)/ShortestPath.swift

@@ -1,106 +1,107 @@
 // MARK: - Edge
 
-public class Edge: Equatable {
-  public var neighbor: Node
-
-  public init(neighbor: Node) {
-    self.neighbor = neighbor
-  }
+open class Edge: Equatable {
+    open var neighbor: Node
+    
+    public init(neighbor: Node) {
+        self.neighbor = neighbor
+    }
 }
 
 public func == (lhs: Edge, rhs: Edge) -> Bool {
-  return lhs.neighbor == rhs.neighbor
+    return lhs.neighbor == rhs.neighbor
 }
 
-// MARK: - Node
-
-public class Node: CustomStringConvertible, Equatable {
-  public var neighbors: [Edge]
-
-  public private(set) var label: String
-  public var distance: Int?
-  public var visited: Bool
 
-  public init(label: String) {
-    self.label = label
-    neighbors = []
-    visited = false
-  }
+// MARK: - Node
 
-  public var description: String {
-    if let distance = distance {
-      return "Node(label: \(label), distance: \(distance))"
+open class Node: CustomStringConvertible, Equatable {
+    open var neighbors: [Edge]
+    
+    open fileprivate(set) var label: String
+    open var distance: Int?
+    open var visited: Bool
+    
+    public init(label: String) {
+        self.label = label
+        neighbors = []
+        visited = false
+    }
+    
+    open var description: String {
+        if let distance = distance {
+            return "Node(label: \(label), distance: \(distance))"
+        }
+        return "Node(label: \(label), distance: infinity)"
+    }
+    
+    open var hasDistance: Bool {
+        return distance != nil
+    }
+    
+    open func remove(_ edge: Edge) {
+        neighbors.remove(at: neighbors.index { $0 === edge }!)
     }
-    return "Node(label: \(label), distance: infinity)"
-  }
-
-  public var hasDistance: Bool {
-    return distance != nil
-  }
-
-  public func remove(edge: Edge) {
-    neighbors.removeAtIndex(neighbors.indexOf { $0 === edge }!)
-  }
 }
 
 public func == (lhs: Node, rhs: Node) -> Bool {
-  return lhs.label == rhs.label && lhs.neighbors == rhs.neighbors
+    return lhs.label == rhs.label && lhs.neighbors == rhs.neighbors
 }
 
 // MARK: - Graph
 
-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)
-    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})]"
-      }
+open class Graph: CustomStringConvertible, Equatable {
+    open fileprivate(set) var nodes: [Node]
+    
+    public init() {
+        self.nodes = []
     }
-    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)
+    
+    open func addNode(label: String) -> Node {
+        let node = Node(label: label)
+        nodes.append(node)
+        return node
     }
-
-    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)
-      }
+    
+    open func addEdge(_ source: Node, neighbor: Node) {
+        let edge = Edge(neighbor: neighbor)
+        source.neighbors.append(edge)
+    }
+    
+    open 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
+    }
+    
+    open func findNodeWithLabel(label: String) -> Node {
+        return nodes.filter { $0.label == label }.first!
+    }
+    
+    open func duplicate() -> Graph {
+        let duplicated = Graph()
+        
+        for node in nodes {
+            duplicated.addNode(label: node.label)
+        }
+        
+        for node in nodes {
+            for edge in node.neighbors {
+                let source = duplicated.findNodeWithLabel(label: node.label)
+                let neighbour = duplicated.findNodeWithLabel(label: edge.neighbor.label)
+                duplicated.addEdge(source, neighbor: neighbour)
+            }
+        }
+        
+        return duplicated
     }
-
-    return duplicated
-  }
 }
 
 public func == (lhs: Graph, rhs: Graph) -> Bool {
-  return lhs.nodes == rhs.nodes
+    return lhs.nodes == rhs.nodes
 }

Shortest Path (Unweighted)/Tests/Graph.swift

@@ -1,5 +1,5 @@
 public struct Queue<T> {
-  private var array: [T]
+  fileprivate var array: [T]
 
   public init() {
     array = []