Improve graph

Author: hollance

Graph/AdjacencyList.swift

@@ -0,0 +1,39 @@
+private var uniqueIDCounter = 0
+
+public struct Edge<T> {
+  public let from: Vertex<T>
+  public let to: Vertex<T>
+  public let weight: Double
+}
+
+public struct Vertex<T> {
+  public var data: T
+  public let uniqueID: Int
+  
+  private(set) public var edges: [Edge<T>] = []   // the adjacency list
+  
+  public init(data: T) {
+    self.data = data
+    uniqueID = uniqueIDCounter
+    uniqueIDCounter += 1
+  }
+
+  // Creates the directed edge: self -----> dest
+  public mutating func connectTo(destinationVertex: Vertex<T>, withWeight weight: Double = 0) {
+    edges.append(Edge(from: self, to: destinationVertex, weight: weight))
+  }
+  
+  // Creates an undirected edge by making two directed edges: self ----> other, and other ----> self
+  public mutating func connectBetween(inout otherVertex: Vertex<T>, withWeight weight: Double = 0) {
+    connectTo(otherVertex, withWeight: weight)
+    otherVertex.connectTo(self, withWeight: weight)
+  }
+  
+  // Does this vertex have an edge -----> otherVertex?
+  public func edgeTo(otherVertex: Vertex<T>) -> Edge<T>? {
+    for e in edges where e.to.uniqueID == otherVertex.uniqueID {
+      return e
+    }
+    return nil
+  }
+}

Graph/AdjacencyMatrix.swift

@@ -0,0 +1,43 @@
+public struct Vertex<T> {
+  public var data: T
+  private let index: Int
+}
+
+public struct Graph<T> {
+  // If adjacencyMatrix[i][j] is not nil, then there is an edge from
+  // vertex i to vertex j.
+  private var adjacencyMatrix: [[Double?]] = []
+  
+  // Adds a new vertex to the matrix.
+  // Performance: possibly O(n^2) because of the resizing of the matrix.
+  public mutating func createVertex(data: T) -> Vertex<T> {
+    let vertex = Vertex(data: data, index: 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
+  }
+  
+  // Creates a directed edge source -----> dest.
+  public mutating func connect(sourceVertex: Vertex<T>, to destinationVertex: Vertex<T>, withWeight weight: Double = 0) {
+    adjacencyMatrix[sourceVertex.index][destinationVertex.index] = weight
+  }
+  
+  // Creates an undirected edge by making 2 directed edges:
+  // some ----> other, and other ----> some.
+  public mutating func connect(someVertex: Vertex<T>, symmetricallyWithVertex withVertex: Vertex<T>, withWeight weight: Double = 0) {
+    adjacencyMatrix[someVertex.index][withVertex.index] = weight
+    adjacencyMatrix[withVertex.index][someVertex.index] = weight
+  }
+
+  public func weightFrom(sourceVertex: Vertex<T>, toDestinationVertex: Vertex<T>) -> Double? {
+    return adjacencyMatrix[sourceVertex.index][toDestinationVertex.index]
+  }
+}

Graph/Graph.playground/Pages/Adjacency List.xcplaygroundpage/Contents.swift

@@ -1,64 +1,65 @@
-/*
+//: # Graph using an adjacency list
+//:
+//: In an adjacency list implementation of a graph, each vertex stores an
+//: array of edges, indicating to which other vertices it has an edge.
+//: (Note the directionality: we only record "to" edges, not "from" edges.)
 
-A graph implementation, using an adjacency list.
+private var uniqueIDCounter = 0
 
-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.
-
-*/
-
-var uniqueIDCounter: Int = 0
-
-public struct GraphEdge<T> {
-  public let from: GraphVertex<T>
-  public let to: GraphVertex<T>
+public struct Edge<T> {
+  public let from: Vertex<T>
+  public let to: Vertex<T>
   public let weight: Double
 }
 
-
-public struct GraphVertex<T> {
+public struct Vertex<T> {
   public var data: T
-  private var edges: [GraphEdge<T>] = [] // This is an adjacency list, rather than matrix
+  public let uniqueID: Int
 
-  private let uniqueID: Int
+  private(set) public var edges: [Edge<T>] = []   // the adjacency list
 
   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 = 1.0) {
-    edges.append(GraphEdge(from: self, to: destinationVertex, weight: weight))
+
+  // Creates the directed edge: self -----> dest
+  public mutating func connectTo(destinationVertex: Vertex<T>, withWeight weight: Double = 0) {
+    edges.append(Edge(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 = 1.0) {  
+  // Creates an undirected edge by making two directed edges: self ----> other, and other ----> self
+  public mutating func connectBetween(inout otherVertex: Vertex<T>, withWeight weight: Double = 0) {
     connectTo(otherVertex, withWeight: weight)
     otherVertex.connectTo(self, withWeight: weight)
   }
 
-  // Queries for an edge from self -----> otherVertex
-  public func edgeTo(otherVertex: GraphVertex<T>) -> GraphEdge<T>? {
-    for e in edges {
-      if e.to.uniqueID == otherVertex.uniqueID {
-        return e
-      }
+  // Does this vertex have an edge -----> otherVertex?
+  public func edgeTo(otherVertex: Vertex<T>) -> Edge<T>? {
+    for e in edges where e.to.uniqueID == otherVertex.uniqueID {
+      return e
     }
-    
     return nil
   }
 }
 
 
 
-// Create 4 separate vertices
-var v1 = GraphVertex(data: 1)
-var v2 = GraphVertex(data: 2)
-var v3 = GraphVertex(data: 3)
-var v4 = GraphVertex(data: 4)
+//: ### Demo
+
+// Create the vertices
+var v1 = Vertex(data: 1)
+var v2 = Vertex(data: 2)
+var v3 = Vertex(data: 3)
+var v4 = Vertex(data: 4)
+var v5 = Vertex(data: 5)
 
-// Setup a cycle like so:
+// Set up a cycle like so:
+//               v5
+//                ^
+//                | (3.2)
+//                |
 // v1 ---(1)---> v2 ---(1)---> v3 ---(4.5)---> v4
 // ^                                            |
 // |                                            V
@@ -68,6 +69,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)
+v2.connectTo(v5, withWeight: 3.2)
+
 
 // Returns the weight of the edge from v1 to v2 (1.0)
 v1.edgeTo(v2)?.weight
@@ -80,4 +83,5 @@ v3.edgeTo(v4)?.weight
 
 // Returns the weight of the edge from v4 to v1 (2.8)
 v4.edgeTo(v1)?.weight
-//: [Next](@next)
+
+//: [Next: Adjacency Matrix](@next)

Graph/Graph.playground/Pages/Adjacency Matrix.xcplaygroundpage/Contents.swift

@@ -1,75 +1,87 @@
-//: [Previous](@previous)
-/*
+//: [Previous: Adjacency List](@previous)
 
-A graph implementation, using an adjacency matrix.
+//: # Graph using an adjacency matrix
+//:
+//: In an adjacency matrix implementation, each vertex is given an index 
+//: from `0..<V`, where `V` is the total number of vertices. The matrix is 
+//: a 2D array, with each entry indicating if the corresponding two vertices
+//: are connected, and the weight of that edge.
+//:
+//: For example, if `matrix[3][5] = 4.6`, then vertex #3 is connected to
+//: vertex #5, with a weight of 4.6. Note that vertex #5 is not necessarily
+//: connected back to vertex #3 (that would be recorded in `matrix[5][3]`).
 
-In an adjacency matrix implementation, each vertex is associated with an index from 0..<V (V being the number of vertices). Then a matrix (a 2D array) is stored for the entire graph, with each entry indicating if the corresponding vertices are connected, and the weight.  For example, if matrix[3][5] = 4.6, then vertex #3 is connected to vertex #5, with a weight of 4.6.  Note that vertex #5 is not necessarily connected to vertex #3.
-
-*/
-
-public struct GraphVertex<T> {
+public struct Vertex<T> {
   public var data: T
   private let index: 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.
+  // If adjacencyMatrix[i][j] is not nil, then there is an edge from
+  // vertex i to vertex j.
   private var adjacencyMatrix: [[Double?]] = []
 
-  // Possibly O(n^2) because of the resizing of the matrix
-  public mutating func createVertex(data: T) -> GraphVertex<T> {
-    let vertex = GraphVertex(data: data, index: adjacencyMatrix.count)
+  // Adds a new vertex to the matrix.
+  // Performance: possibly O(n^2) because of the resizing of the matrix.
+  public mutating func createVertex(data: T) -> Vertex<T> {
+    let vertex = Vertex(data: data, index: adjacencyMatrix.count)
 
-    // Expand each existing row to the right one column
+    // 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
+    // Add one new row at the bottom.
     let newRow = [Double?](count: adjacencyMatrix.count + 1, repeatedValue: nil)
     adjacencyMatrix.append(newRow)
-    
+
     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.index][toDestinationVertex.index] = weight
+  // Creates a directed edge source -----> dest.
+  public mutating func connect(sourceVertex: Vertex<T>, to destinationVertex: Vertex<T>, withWeight weight: Double = 0) {
+    adjacencyMatrix[sourceVertex.index][destinationVertex.index] = 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) {
+  // Creates an undirected edge by making 2 directed edges:
+  // some ----> other, and other ----> some.
+  public mutating func connect(someVertex: Vertex<T>, symmetricallyWithVertex withVertex: Vertex<T>, withWeight weight: Double = 0) {
     adjacencyMatrix[someVertex.index][withVertex.index] = weight
     adjacencyMatrix[withVertex.index][someVertex.index] = weight
   }
-  
-  public func weightFrom(sourceVertex: GraphVertex<T>, toDestinationVertex: GraphVertex<T>) -> Double? {
+
+  public func weightFrom(sourceVertex: Vertex<T>, toDestinationVertex: Vertex<T>) -> Double? {
     return adjacencyMatrix[sourceVertex.index][toDestinationVertex.index]
   }
-  
 }
 
 
 
-// Create 4 separate vertices
+//: ### Demo
+
+// Create the vertices
 var graph = Graph<Int>()
 let v1 = graph.createVertex(1)
 let v2 = graph.createVertex(2)
 let v3 = graph.createVertex(3)
 let v4 = graph.createVertex(4)
+let v5 = graph.createVertex(5)
 
-// Setup a cycle like so:
+// Set up a cycle like so:
+//               v5
+//                ^
+//                | (3.2)
+//                |
 // 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)
+graph.connect(v1, to: v2, withWeight: 1.0)
+graph.connect(v2, to: v3, withWeight: 1.0)
+graph.connect(v3, to: v4, withWeight: 4.5)
+graph.connect(v4, to: v1, withWeight: 2.8)
+graph.connect(v2, to: v5, withWeight: 3.2)
 
 // Returns the weight of the edge from v1 to v2 (1.0)
 graph.weightFrom(v1, toDestinationVertex: v2)
@@ -83,3 +95,5 @@ graph.weightFrom(v3, toDestinationVertex: v4)
 // Returns the weight of the edge from v4 to v1 (2.8)
 graph.weightFrom(v4, toDestinationVertex: v1)
 
+print(graph.adjacencyMatrix)
+