You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
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*.
3
+
Topological sort is an algorithm that orders a directed graph such that for each directed edge *u→v*, vertex *u* comes before vertex*v*.
4
4
5
-
In other words, a topological sort places the vertices of a directed acyclic graph on a line so that all directed edges go from left to right.
5
+
In other words, a topological sort places the vertices of a [directed acyclic graph](../Graph/) on a line so that all directed edges go from left to right.
6
6
7
-
The graph in the following example has two possible topological sorts:
7
+
Consider the graph in the following example:
8
+
9
+
10
+
11
+
This graph has two possible topological sorts:
8
12
9
13
10
14
15
+
The topological orderings are **S, V, W, T, X** and **S, W, V, T, X**. Notice how the arrows all go from left to right.
16
+
17
+
The following is not a valid topological sort for this graph, since **X** and **T** cannot happen before **V**:
18
+
19
+
20
+
11
21
## Where is this used?
12
22
13
-
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.
23
+
Let's consider that you want to learn all the algorithms and data structures from the Swift Algorithm Club. This might seem daunting at first but we can use topological sort to get things organized.
14
24
15
-
For example, to learn the [depth-first search](../Depth-First Search/) algorithm you need to know how a [graph](../Graph/) is represented. Similarly, to understand how to calculate the length of a [binary tree](../Binary Tree/) you need to know details of how a [tree is traversed](../Tree/).
25
+
Since you're learning about topological sort, let's take this topic as an example. What else do you need to learn first before you can fully understand topological sort? Well, topological sort uses [depth-first search](../Depth-First Search/) as well as a [stack](../Stack/). But before you can learn about the depth-first search algorithm, you need to know what a [graph](../Graph/) is, and it helps to know what a [tree](../Tree/)is. In turn, graphs and trees use the idea of linking objects together, so you may need to read up on that first. And so on...
16
26
17
-
If we were to represent these objectives in the form of a graph it would be as follows:
27
+
If we were to represent these objectives in the form of a graph it would look as follows:
18
28
19
-
29
+
20
30
21
-
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.
31
+
If we consider each algorithm to be a vertex in the graph you can clearly see the dependencies between them. 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 do first.
22
32
23
33
## How does it work?
24
34
25
-
**Step 1: Find all nodes that have in-degree of 0**
35
+
**Step 1: Find all vertices that have in-degree of 0**
36
+
37
+
The *in-degree* of a vertex is the number of edges pointing at that vertex. Vertices with no incoming edges have an in-degree of 0. These vertices are the starting points for the topological sort.
38
+
39
+
In the context of the previous example, these vertices represent algorithms that don't have any prerequisites; you don't need to learn anything else first, hence the sort starts with them.
26
40
27
-
The *in-degree* of a node is the number of incoming edges to that node. Nodes that have no incoming edges have an in-degree of 0. These nodes are the starting points for the sort.
41
+
**Step 2: Traverse the graph with depth-first search**
28
42
29
-
If you think about it in the context of the previous example, these nodes represent algorithms that don't have any prerequisites; you don't need to learn anything else first, hence the sort starts with them.
43
+
Depth-first search is an algorithm that starts traversing the graph from a certain vertex and explores as far as possible along each branch before backtracking. To find out more about depth-first search, please take a look at the [detailed explanation](../Depth-First%20Search/).
30
44
31
-
**Step 2: Depth-first search for traversal**
45
+
We perform a depth-first search on each vertex with in-degree 0. This tells us which vertices are connected to each of these starting vertices.
32
46
33
-
Depth-first search is an algorithm that is used to traverse a graph. This algorithm traverses all the child nodes recursively and uses backtracking.
47
+
**Step 3: Remember all visited vertices**
34
48
35
-
To find out more about depth-first search, please take a look at the [detailed explanation](../Depth-First%20Search/).
49
+
As we perform the depth-first search, we maintain a list of all the vertices that have been visited. This is to avoid visiting the same vertex twice.
36
50
37
-
**Step 3: Remember all visited nodes**
51
+
**Step 4: Put it all together**
38
52
39
-
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.
53
+
The last step of the sort is to combine the results of the different depth-first searches and put the vertices in a sorted list.
40
54
41
55
## Example
42
56
43
57
Consider the following graph:
44
58
45
-
59
+
46
60
47
-
**Step 1:** The nodes with 0 in-degree are: **5, 7, 3**
61
+
**Step 1:** The vertices with 0 in-degree are: **3, 7, 5**. These are our starting vertices.
48
62
49
-
**Step 2:**Depth-first search for each starting node, without remembering nodes that have already been visited:
63
+
**Step 2:**Perform depth-first search for each starting vertex, without remembering vertices that have already been visited:
50
64
51
65
```
52
-
Node 3: 3, 8, 9, 10
53
-
Node 7: 7, 11, 2, 8, 9
54
-
Node 5: 5, 11, 2, 9, 10
66
+
Vertex 3: 3, 8, 9, 10
67
+
Vertex 7: 7, 11, 2, 8, 9
68
+
Vertex 5: 5, 11, 2, 9, 10
55
69
```
56
70
57
-
**Step 3:**Remember nodes already visited in each DFS:
71
+
**Step 3:**Filter out the vertices already visited in each previous search:
58
72
59
73
```
60
-
Node 3: 3, 8, 9, 10
61
-
Node 7: 7, 11, 2
62
-
Node 5: 5
74
+
Vertex 3: 3, 8, 9, 10
75
+
Vertex 7: 7, 11, 2
76
+
Vertex 5: 5
63
77
```
64
78
65
-
The final sorted order is a concatenation of the above three traversals: **3, 8, 9, 10, 7, 11, 2, 5**
79
+
**Step 4:** Combine the results of these three depth-first searches. The final sorted order is **5, 7, 11, 2, 3, 8, 9, 10**. (Important: we need to add the results of each subsequent search to the *front* of the list.)
66
80
67
81
The result of the topological sort looks like this:
68
82
69
83
70
84
71
-
TODO: I don't think this is correct! There should be no arrows going from right to left! (A valid topological order would be 3, 7, 5, 10, 8, 11, 9, 2 -- or 3, 7, 5, 8, 11, 2, 9, 10.)
85
+
> **Note:** This is not the only possible topological sort for this graph. For example, other valid solutions are **3, 7, 5, 10, 8, 11, 9, 2** and **3, 7, 5, 8, 11, 2, 9, 10**. Any order where all the arrows are going from left to right will do.
86
+
87
+
## The code
88
+
89
+
Here is how you could implement topological sort in Swift (see also [TopologicalSort1.swift](TopologicalSort1.swift)):
90
+
91
+
```swift
92
+
extensionGraph {
93
+
publicfunctopologicalSort() -> [Node] {
94
+
// 1
95
+
let startNodes =calculateInDegreeOfNodes().filter({ _, indegree in
96
+
return indegree ==0
97
+
}).map({ node, indegree in
98
+
return node
99
+
})
100
+
101
+
// 2
102
+
var visited = [Node :Bool]()
103
+
for (node, _) in adjacencyLists {
104
+
visited[node] =false
105
+
}
106
+
107
+
// 3
108
+
var result = [Node]()
109
+
for startNode in startNodes {
110
+
result =depthFirstSearch(startNode, visited: &visited) + result
111
+
}
112
+
113
+
// 4
114
+
return result
115
+
}
116
+
}
117
+
```
118
+
119
+
Some remarks:
120
+
121
+
1. Find the in-degree of each vertex and put all the vertices with in-degree 0 in the `startNodes` array. In this graph implementation, vertices are called "nodes". Both terms are used interchangeably by people who write graph code.
122
+
123
+
2. The `visited` array keeps track of whether we've already seen a vertex during the depth-first search. Initially, we set all elements to `false`.
124
+
125
+
3. For each of the vertices in the `startNodes` array, perform a depth-first search. This returns an array of `Node` objects. We prepend that array to our own `result` array.
126
+
127
+
4. The `result` array contains all the vertices in topologically sorted order.
72
128
73
-
## Alternative algorithm
129
+
## Alternative method (Kahn's algorithm)
74
130
75
131
Even though depth-first search is the typical way to perform a topological sort, there is another algorithm that also does the job.
76
132
@@ -82,6 +138,6 @@ Even though depth-first search is the typical way to perform a topological sort,
82
138
83
139
This is an **O(n + m)** algorithm where **n** is the number of vertices and **m** is the number of edges. You can see the implementation in [TopologicalSort2.swift](TopologicalSort2.swift).
84
140
85
-
I first read about this algorithm in the Algorithm Alley column in Dr. Dobb's Magazine from May 1993.
141
+
Source: I first read about this alternative algorithm in the Algorithm Alley column in Dr. Dobb's Magazine from May 1993.
86
142
87
143
*Written for Swift Algorithm Club by Ali Hafizji and Matthijs Hollemans*
0 commit comments