Interview Camp
Technique: Topological Sort
Level: Hard
Sort a graph in topological order.
Questions to Clarify:
Q. For the output, can I return a Stack which contains the nodes in order?
A. Yes (If interviewer wants a list, simply convert the stack to a list in the code)
Q. Is this a directed graph?
A. Yes. (Point out that Topological sort not possible with undirected graph)
Q. Can we assume that the graph has no cycles?
A. Yes. (We do a section on detecting cycles later)
Solution:
Topological sort is very useful in scheduling problems, or when you need to arrange a
graph in order. A topological sort is an ordering of nodes. We arrange nodes such that
for each node N, all its edges point to a node ahead of N.
You could use topological sort to solve several types of problems. For example, say that
you are given a graph of college classes. Each Node represents a class and each edge conveys
that a class is a prerequisite for another. You can use topological sort to calculate the
minimum number of semesters to complete the classes. Check out the video for more details.
You could also use it to find the longest path in a graph, which we will do in the homework
problems.
Note: Topological Sort is only possible if the Graph has no cycles.
It is also applicable only to directed graphs. In undirected graphs, every edge
can be considered a cycle since it points both ways.
To implement Topological sort, you simply add 1 line to Depth First Search (DFS).
At the end of the dfsVisit() function call, simply add the visited node to a stack.
At the end of the DFS, the stack will contain the nodes in topological order. Try it yourself
with examples.
Pseudocode:
dfsVisit(Node, Stack)
Node.state = VISITING
For each neighbor:
if Neighbor is UNVISITED
perform dfsVisit on Neighbor
Node.state = VISITED
© 2017 Interview Camp (interviewcamp.io)
Interview Camp
Stack.push(Node)
topoSort(Graph)
Stack = empty
for all nodes in Graph:
if node is UNVISITED, perform dfsVisit(node, Stack)
return Stack
Test Cases:
Edge Cases: empty graph, null graph
Base Cases: single node graph, 2 node graph, 2 node unconnected
Regular Cases: multiple nodes, multiple connected components
Time Complexity: O(V + E), where V is vertices (nodes) and E is edges.
Space Complexity: O(V)
public static Stack<Node> topoSort(Graph graph) {
Stack<Node> stack = new Stack<>();
for(Node node : graph.getNodes()) {
if (node.getState() == State.UNVISITED)
dfsVisit(node, stack);
}
return stack;
}
public static void dfsVisit(Node node, Stack<Node> stack) {
node.setState(State.VISITING);
for (Node neighbor: node.getNeighbors()) {
if (neighbor.getState() == State.UNVISITED)
dfsVisit(neighbor, stack);
}
node.setState(State.VISITED);
stack.push(node);
}
/*
* Helper Code. Ask interviewer before implementing.
*/
public enum State {
UNVISITED,
VISITING,
VISITED;
© 2017 Interview Camp (interviewcamp.io)
Interview Camp
public class Graph {
List<Node> nodes;
public Graph(List<Node> nodes) {
super();
this.nodes = nodes;
}
public void addNode(Node node) {
nodes.add(node);
}
public List<Node> getNodes() {
return nodes;
}
}
public class Node {
List<Node> neighbors;
int data;
State state;
public Node(int data) {
super();
this.data = data;
state = State.UNVISITED;
neighbors = new ArrayList<Node>();
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public void setState(State state) {
this.state = state;
}
public State getState() {
return state;
}
© 2017 Interview Camp (interviewcamp.io)
Interview Camp
public void addNeighbor(Node node) {
neighbors.add(node);
}
public List<Node> getNeighbors() {
return neighbors;
}
}
© 2017 Interview Camp (interviewcamp.io)
