topological-sort | Topological sort implemented in Javascript / Typescript

Specifically, the complexity would be more accurately stated as V + 2E (which has overall complexity class O(V + E). We iterate over each vertex exactly once, and each edge exactly twice (once for each vertex it's attached to) - assuming that graph[vertex] returns only the edges attached to that vertex, which seems to be the algorithm's intention.

Nested loops does usually indicate a * instead of a +, where complexity is concerned. If the inner loop is iterating over something different than the outer loop, however, we sometimes get cases like this - where there's a specific and constant number of things across all inner loops, distributed somehow across each element of the outer loops.

In such a case, we can indeed write the complexity as O(V + E), because the number of E we iterate over isn't tied in any way to the number of V we iterate over - just the order in which we do so, which complexity doesn't really care about.

The IndexError: list index out of range is caused because this example code assumes that vertices are numbered starting with zero.

The list visited is initialized as:

You could also do it like that, however what this website is creating is an array of lists, not exactly a list of lists. I think this approach (array of lists) is the usual way to represent adjacency lists in lots of programming languages. In this way the vertices are numbered from 0 to V-1, and you can access the list of adjacents directly by using the index operator adj[i]

I don't really know the exact reason, but I imagine it's for efficiency purposes.

EDIT: Notice that lists are, according the C++ reference, double-linked lists, so if you want to access element i, an iteration through the linked nodes is needed until you reach element i. With an array, you access directly the list that you are interested in, without iterating and therefore more efficiently. In www.cplusplus.com we can read:

The main drawback of lists and forward_lists compared to these other sequence containers is that they lack direct access to the elements by their position; For example, to access the sixth element in a list, one has to iterate from a known position (like the beginning or the end) to that position, which takes linear time in the distance between these. They also consume some extra memory to keep the linking information associated to each element (which may be an important factor for large lists of small-sized elements).

It's building the output vector backwards. If there's an incoming directed edge from vertex (1) to vertex (0), you want to output (0) before (1).

Note that dfs(int v) calls ans.push_back(v) only after it recurses to all its descendants. This ensures that anything that follows v will have been added to the output vector before v. Anything not visited[] after dfs(0) returns is either unrelated to 0 or its descendants (and therefore can be added later), or precedes them (and therefore should be added later).

In short: You are changing the size of the defaultdict by accessing a non-existing member.

You are doing the following:

1. Loop over self.adj_list, which is (despite the name) a defaultdict

2. Call Topological_Sort_Util with a node from self.adj_list (so far so good)

3. Loop over the children in self.adj_list[input_node]

4. Call Topological_Sort_Util recursively with the children of the node

The last step is where things go wrong in your example. Node 1 has node 3 as the only child, but you never add node 3 to adj_list. Because adj_list is a defaultdict, the line