Merge pull request #68 from aliHafizji/topological_sort

Add Topological Sort

Author: hollance

Topological Sort/Images/algorithm_example.png

@@ -0,0 +1,56 @@
+# Topological Sort
+
+Topological sort is an algorithm aimed at ordering a directed graph such that for each directed edge *uv* from vertex *u* to vertex *v*, *u* comes before *v*.
+
+## Where is this used?
+
+Let's consider that you want to learn all the algorithms present in the swift-algorithm-club, this might seem daunting at first but  we can use topological sort to get things organized.
+
+For e.g. To learn the depth first search algorithm you need to know how a graph is represented. Similarly, to understand how to calculate the length of a binary tree you need to know details of how a tree is traversed. If we were to represent these in the form of a graph it would be as follows:
+
+![Example](Images/algorithm_example.png)
+
+If we consider each algorithm to be a node in the graph you'll see dependancies among them i.e. to learn something you might have to know something else first. This is exactly what topological sort is used for, it will sort things out such that you know what to learn first.
+
+## How does it work?
+
+### Step 1: Find all nodes that have in-degree of 0
+
+The in-degree of a node is the number of incoming edges to that node. All nodes that have no incoming edges have an in-degree of 0. These nodes are the starting points for the sort.
+
+If you think about it in the context of the previous example these nodes represent algorithms that don't need anything else to be learnt, hence the sort starts with them.
+
+### Step 2: Depth first search for traversal
+
+Depth first search is an algorithm that is used to traverse a graph. This algorithm traverses all the child nodes recursively and uses backtracking.
+
+To know more about this algorithm please take a look at the explanation [here](https://github.com/hollance/swift-algorithm-club/tree/master/Depth-First%20Search).
+
+### Step 3: Remember all visited nodes
+
+The last step of the sort is to maintain a list of all the nodes that have been visited. This is to avoid visiting the same node twice.
+
+## Example
+
+Consider the following graph:
+
+![Graph Example](Images/graph_example.png)
+
+*Step 1* Nodes with 0 in-degree: **5, 7, 3**
+*Step 2* Depth first search for each without remembering nodes that have already been visited:
+
+```
+Node 3: 3, 8, 9, 10
+Node 7: 7, 11, 2, 8, 9
+Node 5: 5, 11, 2, 9, 10
+```
+
+*Step 3* Remember nodes already visited in each DFS.
+
+```
+Node 3: 3, 8, 9, 10
+Node 7: 7, 11, 2
+Node 5: 5
+```
+
+The final sorted order is a concatenation of the above three traversals: **3, 8, 9, 10, 7, 11, 2, 5**

Topological Sort/Images/graph_example.png

@@ -0,0 +1,27 @@
+//: Playground - noun: a place where people can play
+
+import UIKit
+
+let graph = Graph()
+
+let node5 = graph.addNode("5")
+let node7 = graph.addNode("7")
+let node3 = graph.addNode("3")
+let node11 = graph.addNode("11")
+let node8 = graph.addNode("8")
+let node2 = graph.addNode("2")
+let node9 = graph.addNode("9")
+let node10 = graph.addNode("10")
+
+graph.addEdge(fromNode: node5, toNode: node11)
+graph.addEdge(fromNode: node7, toNode: node11)
+graph.addEdge(fromNode: node7, toNode: node8)
+graph.addEdge(fromNode: node3, toNode: node8)
+graph.addEdge(fromNode: node3, toNode: node10)
+graph.addEdge(fromNode: node11, toNode: node2)
+graph.addEdge(fromNode: node11, toNode: node9)
+graph.addEdge(fromNode: node11, toNode: node10)
+graph.addEdge(fromNode: node8, toNode: node9)
+
+
+graph.topologicalSort()

Topological Sort/README.markdown

@@ -0,0 +1,91 @@
+public class Graph: CustomStringConvertible {
+  
+  public typealias Node = String
+  
+  private var adjacencyLists: [Node : [Node]]
+  
+  public init() {
+    adjacencyLists = [Node : [Node]]()
+  }
+  
+  public func addNode(value: Node) -> Node {
+    adjacencyLists[value] = []
+    return value
+  }
+  
+  public func addEdge(fromNode from: Node, toNode to: Node) -> Bool {
+    adjacencyLists[from]?.append(to)
+    return adjacencyLists[from] != nil ? true : false
+  }
+  
+  public var description: String {
+    return adjacencyLists.description
+  }
+  
+  private func adjacencyList(forNode node: Node) -> [Node]? {
+    for (key, adjacencyList) in adjacencyLists {
+      if key == node {
+        return adjacencyList
+      }
+    }
+    return nil
+  }
+}
+
+extension Graph {
+  
+  typealias InDegree = Int
+  private func calculateInDegreeOfNodes() -> [Node : InDegree] {
+    
+    var inDegrees = [Node : InDegree]()
+    
+    for (node, _) in adjacencyLists {
+      inDegrees[node] = 0
+    }
+    
+    for (_, adjacencyList) in adjacencyLists {
+      for nodeInList in adjacencyList {
+        inDegrees[nodeInList] = (inDegrees[nodeInList] ?? 0) + 1
+      }
+    }
+    return inDegrees
+  }
+  
+  private func depthFirstSearch(source: Node, inout visited: [Node : Bool]) -> [Node] {
+    var result = [source]
+    visited[source] = true
+    
+    if let adjacencyList = adjacencyList(forNode: source) {
+      for nodeInAdjacencyList in adjacencyList {
+        if !(visited[nodeInAdjacencyList] ?? false) {
+          result += (depthFirstSearch(nodeInAdjacencyList, visited: &visited))
+        }
+      }
+    }
+    
+    return result
+  }
+  
+  public func topologicalSort() -> [Node] {
+    
+    let startNodes = calculateInDegreeOfNodes().filter({(_, indegree) in
+      return indegree == 0
+    }).map({(node, indegree) in
+      return node
+    })
+    
+    var visited = [Node : Bool]()
+    
+    for (node, _) in adjacencyLists {
+      visited[node] = false
+    }
+    
+    var result = [Node]()
+    
+    for startNode in startNodes {
+      result += depthFirstSearch(startNode, visited: &visited)
+    }
+    
+    return result
+  }
+}

Topological Sort/Topological Sort.playground/Contents.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+public struct Stack<T> {
+  private var array = [T]()
+  
+  public var isEmpty: Bool {
+    return array.isEmpty
+  }
+  
+  public var count: Int {
+    return array.count
+  }
+  
+  public mutating func push(element: T) {
+    array.append(element)
+  }
+  
+  public mutating func pop() -> T? {
+    if isEmpty {
+      return nil
+    } else {
+      return array.removeLast()
+    }
+  }
+  
+  public func peek() -> T? {
+    return array.last
+  }
+}
+
+extension Stack: SequenceType {
+  public func generate() -> AnyGenerator<T> {
+    var curr = self
+    return anyGenerator {
+      _ -> T? in
+      return curr.pop()
+    }
+  }
+}

Topological Sort/Topological Sort.playground/Sources/Graph.swift

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Topological Sort/Topological Sort.playground/Sources/Stack.swift

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