Fix formatting, implement methods to lookup edges.

Author: donald-pinckney

Graph/Graph Adjacency Matrix.playground/Contents.swift

@@ -4,34 +4,51 @@ A graph implementation, using an adjacency list.
 
 In an adjacency list implementation, each vertex stores an array of edges, indicating to which vertices it has an edge (note the directionality).  The edge stores the source and destination vertices, as well as a weight.
 
-Connected vertices in this implementation is O(1).
+Connecting vertices in this implementation is O(1).
 
 */
 
+var uniqueIDCounter: Int = 0
+
 public struct GraphEdge<T> {
   public let from: GraphVertex<T>
   public let to: GraphVertex<T>
   public let weight: Double
 }
 
+
 public struct GraphVertex<T> {
   public var data: T
-  public private(set) var edges: [GraphEdge<T>] = [] // This is a simple adjacency list, rather than matrix
+  public private(set) var edges: [GraphEdge<T>] = [] // This is an adjacency list, rather than matrix
+  
+  private let uniqueID: Int
 
   public init(data: T) {
     self.data = data
+    uniqueID = uniqueIDCounter
+    uniqueIDCounter += 1
   }
 
   // Creates a directed edge self -----> dest
-  public mutating func connectTo(destinationVertex: GraphVertex<T>, withWeight weight: Double = 0) {
+  public mutating func connectTo(destinationVertex: GraphVertex<T>, withWeight weight: Double = 1.0) {
     edges.append(GraphEdge(from: self, to: destinationVertex, weight: weight))
   }
 
   // Creates an undirected edge by making 2 directed edges: self ----> other, and other ----> self
-  public mutating func connectBetween(inout otherVertex: GraphVertex<T>, withWeight weight: Double = 0) {
+  public mutating func connectBetween(inout otherVertex: GraphVertex<T>, withWeight weight: Double = 1.0) {
     edges.append(GraphEdge(from: self, to: otherVertex, weight: weight))
     otherVertex.edges.append(GraphEdge(from: otherVertex, to: self, weight: weight))
   }
+  
+  public func edgeTo(otherVertex: GraphVertex<T>) -> GraphEdge<T>? {
+    for e in edges {
+      if e.to.uniqueID == otherVertex.uniqueID {
+        return e
+      }
+    }
+    
+    return nil
+  }
 }
 
 
@@ -43,15 +60,25 @@ var v3 = GraphVertex(data: 3)
 var v4 = GraphVertex(data: 4)
 
 // Setup a cycle like so:
-// v1 ---> v2 ---> v3 ---> v4
-// ^                       |
-// |                       V
-// -----------<------------|
+// v1 ---(1)---> v2 ---(1)---> v3 ---(4.5)---> v4
+// ^                                            |
+// |                                            V
+// ---------<-----------<---------(2.8)----<----|
+
+v1.connectTo(v2, withWeight: 1.0)
+v2.connectTo(v3, withWeight: 1.0)
+v3.connectTo(v4, withWeight: 4.5)
+v4.connectTo(v1, withWeight: 2.8)
+
+// Returns the weight of the edge from v1 to v2 (1.0)
+v1.edgeTo(v2)?.weight
 
-v1.connectTo(v2)
-v2.connectTo(v3)
-v3.connectTo(v4)
-v4.connectTo(v1)
+// Returns the weight of the edge from v1 to v3 (nil, since there is not an edge)
+v1.edgeTo(v3)?.weight
 
+// Returns the weight of the edge from v3 to v4 (4.5)
+v3.edgeTo(v4)?.weight
 
+// Returns the weight of the edge from v4 to v1 (2.8)
+v4.edgeTo(v1)?.weight
 //: [Next](@next)

Graph/Graph Adjacency Matrix.playground/contents.xcplayground

@@ -11,43 +11,49 @@ Connecting vertices os O(1).
 */
 
 public struct GraphVertex<T> {
-    public var data: T
-    private let uniqueID: Int
+  public var data: T
+  private let uniqueID: Int
 }
 
 public struct Graph<T> {
+  
+  // nil entries are used to mark that two vertices are NOT connected.
+  // If adjacencyMatrix[i][j] is not nil, then there is an edge from vertex i to vertex j.
+  private var adjacencyMatrix: [[Double?]] = []
+  
+  public init() { }
+  
+  public mutating func createVertex(data: T) -> GraphVertex<T> {
+    let vertex = GraphVertex(data: data, uniqueID: adjacencyMatrix.count)
 
-    // nil entries are used to mark that two vertices are NOT connected.
-    private var adjacencyMatrix: [[Double?]] = []
-    
-    public init() { }
-    
-    public mutating func createVertex(data: T) -> GraphVertex<T> {
-        let vertex = GraphVertex(data: data, uniqueID: adjacencyMatrix.count)
-        
-        // Expand each existing row to the right one column
-        for i in 0..<adjacencyMatrix.count {
-            adjacencyMatrix[i].append(nil)
-        }
-        
-        // Add one new row at the bottom
-        let newRow = [Double?](count: adjacencyMatrix.count + 1, repeatedValue: nil)
-        adjacencyMatrix.append(newRow)
-        
-        return vertex
+    // Expand each existing row to the right one column
+    for i in 0..<adjacencyMatrix.count {
+      adjacencyMatrix[i].append(nil)
     }
 
-    // Creates a directed edge source -----> dest.  Represented by M[source][dest] = weight
-    public mutating func connect(sourceVertex: GraphVertex<T>, toDestinationVertex: GraphVertex<T>, withWeight weight: Double = 0) {
-        adjacencyMatrix[sourceVertex.uniqueID][toDestinationVertex.uniqueID] = weight
-    }
+    // Add one new row at the bottom
+    let newRow = [Double?](count: adjacencyMatrix.count + 1, repeatedValue: nil)
+    adjacencyMatrix.append(newRow)
 
-    // Creates an undirected edge by making 2 directed edges: some ----> other, and other ----> some
-    public mutating func connect(someVertex: GraphVertex<T>, withVertex: GraphVertex<T>, withWeight weight: Double = 0) {
-        adjacencyMatrix[someVertex.uniqueID][withVertex.uniqueID] = weight
-        adjacencyMatrix[withVertex.uniqueID][someVertex.uniqueID] = weight
-        
-    }
+    return vertex
+  }
+  
+  // Creates a directed edge source -----> dest.  Represented by M[source][dest] = weight
+  public mutating func connect(sourceVertex: GraphVertex<T>, toDestinationVertex: GraphVertex<T>, withWeight weight: Double = 0) {
+    adjacencyMatrix[sourceVertex.uniqueID][toDestinationVertex.uniqueID] = weight
+  }
+  
+  // Creates an undirected edge by making 2 directed edges: some ----> other, and other ----> some
+  public mutating func connect(someVertex: GraphVertex<T>, symmetricallyWithVertex withVertex: GraphVertex<T>, withWeight weight: Double = 0) {
+    adjacencyMatrix[someVertex.uniqueID][withVertex.uniqueID] = weight
+    adjacencyMatrix[withVertex.uniqueID][someVertex.uniqueID] = weight
+    
+  }
+  
+  public func weightFrom(sourceVertex: GraphVertex<T>, toDestinationVertex: GraphVertex<T>) -> Double? {
+    return adjacencyMatrix[sourceVertex.uniqueID][toDestinationVertex.uniqueID]
+  }
+  
 }
 
 
@@ -60,12 +66,25 @@ let v3 = graph.createVertex(3)
 let v4 = graph.createVertex(4)
 
 // Setup a cycle like so:
-// v1 ---> v2 ---> v3 ---> v4
-// ^                       |
-// |                       V
-// -----------<------------|
-
-graph.connect(v1, toDestinationVertex: v2)
-graph.connect(v2, toDestinationVertex: v3)
-graph.connect(v3, toDestinationVertex: v4)
-graph.connect(v4, toDestinationVertex: v1)
+// v1 ---(1)---> v2 ---(1)---> v3 ---(4.5)---> v4
+// ^                                            |
+// |                                            V
+// ---------<-----------<---------(2.8)----<----|
+
+graph.connect(v1, toDestinationVertex: v2, withWeight: 1.0)
+graph.connect(v2, toDestinationVertex: v3, withWeight: 1.0)
+graph.connect(v3, toDestinationVertex: v4, withWeight: 4.5)
+graph.connect(v4, toDestinationVertex: v1, withWeight: 2.8)
+
+// Returns the weight of the edge from v1 to v2 (1.0)
+graph.weightFrom(v1, toDestinationVertex: v2)
+
+// Returns the weight of the edge from v1 to v3 (nil, since there is not an edge)
+graph.weightFrom(v1, toDestinationVertex: v3)
+
+// Returns the weight of the edge from v3 to v4 (4.5)
+graph.weightFrom(v3, toDestinationVertex: v4)
+
+// Returns the weight of the edge from v4 to v1 (2.8)
+graph.weightFrom(v4, toDestinationVertex: v1)
+