Режим ознакомления ▿

медленно
быстро

Given a graph, we can use the O(V+E) DFS (Depth-First Search) or BFS (Breadth-First Search) algorithm to traverse the graph and explore the features/properties of the graph. Each algorithm has its own characteristics, features, and side-effects that we will explore in this visualization.

This visualization is rich with a lot of DFS and BFS variants (all run in O(V+E)) such as:

1. Topological Sort algorithm (both DFS and BFS/Kahn's algorithm version),
2. Bipartite Graph Checker algorithm (both DFS and BFS version),
3. Cut Vertex & Bridge finding algorithm,
4. Strongly Connected Components (SCC) finding algorithms
(both Kosaraju's and Tarjan's version), and
5. 2-SAT Checker algorithm.

Remarks: By default, we show e-Lecture Mode for first time (or non logged-in) visitor.

X Esc
Вперед PgDn

When the chosen graph traversal algorithm is running, the animation will be shown here.

We use vertex+edge color (the color scheme will be elaborated soon) and occasionally the extra text under the vertex (in red font) to highlight the changes.

All graph traversal algorithms work on directed graphs (this is the default setting, where each edge has an arrowtip to indicate its direction) but the Bipartite Graph Check algorithm and the Cut Vertex & Bridge finding algorithm requires the undirected graphs (the conversion is done automatically by this visualization).

Pro-tip: Since you are not logged-in, you may be a first time visitor who are not aware of the following keyboard shortcuts to navigate this e-Lecture mode: [PageDown] to advance to the next slide, [PageUp] to go back to the previous slide, [Esc] to toggle between this e-Lecture mode and exploration mode.

X Esc
Назад PgUp
Вперед PgDn

There are two different sources for specifying an input graph:

1. Draw Graph: You can draw any unweighted directed graph as the input graph (to draw bidirectional edge (u, v), you can draw two directed edges u → v and v → u).
2. Example Graphs: You can select from the list of our selected example graphs to get you started.

Another pro-tip: We designed this visualization and this e-Lecture mode to look good on 1366x768 resolution or larger (typical modern laptop resolution in 2017). We recommend using Google Chrome to access VisuAlgo. Go to full screen mode (F11) to enjoy this setup. However, you can use zoom-in (Ctrl +) or zoom-out (Ctrl -) to calibrate this.

X Esc
Назад PgUp
Вперед PgDn

If you arrive at this e-Lecture without having first explore/master the concept of Binary Heap and especially Binary Search Tree, we suggest that you explore them first, as traversing a (Binary) Tree structure is much simpler than traversing a general graph.

Quiz: Mini pre-requisite check. What are the Pre-/In-/Post-order traversal of the binary tree shown (root = vertex 0), left and right child are as drawn?

In = 4, 2, 3, 0, 1
Post = 1, 3, 4, 2, 0
Pre = 0, 1, 2, 3, 4
Post = 4, 3, 2, 1, 0
Pre = 0, 2, 4, 3, 1
In = 1, 0, 3, 2, 4
X Esc
Назад PgUp
Вперед PgDn

We normally start from the most important vertex of a (binary) tree: The root vertex.

If the given tree is not 'rooted' (see the example picture), we can pick any one vertex (for example, vertex 0 in the example picture) and designate it as the root. If we imagine that all edges are strings of similar length, then after "virtually pulling the designated root upwards" and let gravity pulls the rest downwards, we have a rooted directed (downwards) tree — see the next slide.

PS: Technically, this transformation is done by running `DFS(0)` that we will explore soon.

X Esc
Назад PgUp
Вперед PgDn

In a binary tree, we only have up to two neighboring choices: From the current vertex, we can go to the left subtree first or go to the right subtree first. We also have option to visit the current vertex before or after visiting one of the (or both) subtree(s).

This gives rise to the classics: pre-order (visit current vertex, visit its left subtree, visit its right subtree), in-order (left, current, right), and post-order (left, right, current) traversals.

Discussion: Do you notice that there are three other possible binary tree traversal combinations? What are they?

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

In a binary tree, or in a tree structure in general, there is no (non-trivial) cycle involving 3 or more distinct vertices to worry about (we do not consider the trivial cycle involving bi-directional edges which can be taken care of easily — see three slides earlier).

X Esc
Назад PgUp
Вперед PgDn

In general graph, we do not have the notion of root vertex. Instead, we need to pick one distinguished vertex to be the starting point of the traversal, i.e. the source vertex s.

We also have 0, 1, ..., k neighbors of a vertex instead of just ≤ 2.

We may (or actually very likely) have cycle(s) in our general graph instead of acyclic tree,
be it the trivial one like u → v → u or the non-trivial one like a → b → c → a.

But fret not, graph traversal is an easy problem with two classic algorithms: DFS and BFS.

X Esc
Назад PgUp
Вперед PgDn

One of the most basic graph traversal algorithm is the O(V+E) Depth-First Search (DFS).

DFS takes one input parameter: The source vertex s.

DFS is one of the most fundamental graph algorithm, so please spend time to understand the key steps of this algorithm.

X Esc
Назад PgUp
Вперед PgDn

The closest analogy of the behavior of DFS is to imagine a maze with only one entrance and one exit. You are at the entrance and want to explore the maze to reach the exit. Obviously you cannot split yourself into more than one.

Ask these reflective questions before continuing: What will you do if there are branching options in front of you? How to avoid going in cycle? How to mark your own path? Hint: You need a chalk, stones (or any other marker) and a (long) string.

X Esc
Назад PgUp
Вперед PgDn

As it name implies, DFS starts from a distinguished source vertex s and uses recursion (an implicit stack) to order the visitation sequence as deep as possible before backtracking.

If DFS is at a vertex u and it has X neighbors, it will pick the first neighbor V1 (usually the vertex with the lowest vertex number), recursively explore all reachable vertices from vertex V1, and eventually backtrack to vertex u. DFS will then do the same for the other neighbors until it finishes exploring the last neighbor VX and its reachable vertices.

This wordy explanation will be clearer with DFS animation later.

X Esc
Назад PgUp
Вперед PgDn

If the graph is cyclic, the previous 'try-all' strategy may lead DFS to run in cycle.

So the basic form of DFS uses an array status[u] of size V vertices to decide between binary conditions: Whether vertex u has been visited or unvisited. Only if vertex u is still unvisited, then DFS can visit vertex u.

When DFS runs out of option, it backtrack to previous vertex (p[u], see the next slide) as the recursion unwinds.

X Esc
Назад PgUp
Вперед PgDn

DFS uses another array p[u] of size V vertices to remember the parent/predecessor/previous of each vertex u along the DFS traversal path.

The predecessor of the source vertex, i.e. p[s] is set to -1 to say that the source vertex has no predecessor (as the lowest vertex number is vertex 0).

The sequence of vertices from a vertex u that is reachable from the source vertex s back to s forms the DFS spanning tree. We color these tree edges with red color.

X Esc
Назад PgUp
Вперед PgDn

For now, ignore the extra status[u] = explored in the displayed pseudocode and the presence of blue and grey edges in the visualization (to be explained soon).

Without further ado, let's execute DFS(0) on the default example graph for this e-Lecture (CP3 Figure 4.1). Recap DFS Example

The basic version of DFS presented so far is already enough for most simple cases.

X Esc
Назад PgUp
Вперед PgDn

The time complexity of DFS is O(V+E) because:

1. Each vertex is only visited once due to the fact that DFS will only recursively explore a vertex u if status[u] = unvisited — O(V)
2. Every time a vertex is visited, all its k neighbors are explored and therefore after all vertices are visited, we have examined all E edges — (O(E) as the total number of neighbors of each vertex equals to E).
X Esc
Назад PgUp
Вперед PgDn

The O(V+E) time complexity of DFS only achievable if we can visit all k neighboring vertices of a vertex in O(k) time.

Quiz: Which underlying graph data structure support that operation?

Edge List

Discussion: Why?

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

Another basic graph traversal algorithm is the O(V+E) Breadth-First Search (BFS).

As with DFS, BFS also takes one input parameter: The source vertex s.

Both DFS and BFS have their own strengths and weaknesses. It is important to learn both and apply the correct graph traversal algorithm for the correct situation.

X Esc
Назад PgUp
Вперед PgDn

Imagine a still body of water and then you throw a stone into it. The first location where the stone hits the water surface is the position of the source vertex and the subsequent ripple effect across the water surface is like the BFS traversal pattern.

X Esc
Назад PgUp
Вперед PgDn

BFS is very similar with DFS that have been discussed earlier, but with some differences.

BFS starts from a source vertex s but it uses a queue to order the visitation sequence as breadth as possible before going deeper.

BFS also uses a Boolean array of size V vertices to distinguish between two states: visited and unvisited vertices (we will not use BFS to detect back edge(s) as with DFS).

In this visualization, we also show that starting from the same source vertex s in an unweighted graph, BFS spanning tree of the graph equals to its SSSP spanning tree.

X Esc
Назад PgUp
Вперед PgDn

Without further ado, let's execute BFS(5) on the default example graph for this e-Lecture (CP3 Figure 4.3). Recap BFS Example.

Notice the Breadth-first exploration due to the usage of FIFO data structure: Queue?

X Esc
Назад PgUp
Вперед PgDn

The time complexity of BFS is O(V+E) because:

1. Each vertex is only visited once as it can only enter the queue once — O(V)
2. Every time a vertex is dequeued from the queue, all its k neighbors are explored and therefore after all vertices are visited, we have examined all E edges — (O(E) as the total number of neighbors of each vertex equals to E).

As with DFS, this O(V+E) time complexity is only possible if we use Adjacency List graph data structure — same reason as with DFS analysis.

X Esc
Назад PgUp
Вперед PgDn

So far, we can use DFS/BFS to solve a few graph traversal problem variants:

1. Detecting if a graph is cyclic,
2. Actually printing the traversal path,
3. Reachability test,
4. Identifying/Counting/Labeling Connected Components (CCs) of undirected graphs,
5. Topological Sort (only on DAGs),

For most data structures and algorithms courses, the applications of DFS/BFS are up to these few basic ones only, although DFS/BFS can do much more...

X Esc
Назад PgUp
Вперед PgDn

We can actually augment the basic DFS further to give more insights about the underlying graph.

In this visualization, we use blue color to highlight back edge(s) of the DFS spanning tree. The presence of at least one back edge shows that the traversed graph (component) is cyclic while its absence shows that at least the component connected to the source vertex of the traversed graph is acyclic.

X Esc
Назад PgUp
Вперед PgDn

Back edge can be detected by modifying array status[u] to record three different states:

1. unvisited: same as earlier, DFS has not reach vertex u before,
2. explored: DFS has visited vertex u, but at least one neighbor of vertex u has not been visited yet (DFS will go depth-first to that neighbor first),
3. visited: now stronger definition: all neighbors of vertex u have also been visited and DFS is about to backtrack from vertex u to vertex p[u].

If DFS is now at vertex x and explore edge x → y and encounter status[y] = explored, we can declare x → y is a back edge (a cycle is found as we were previously at vertex y (hence status[y] = explored), go deep to neighbor of y and so on, but we are now at vertex x that is reachable from y but vertex x leads back to vertex y).

X Esc
Назад PgUp
Вперед PgDn

The edges in the graph that are not tree edge(s) nor back edge(s) are colored grey. They are called forward or cross edge(s) and currently have limited use (not elaborated).

Now try DFS(0) on the example graph above with this new understanding, especially about the 3 possible status of a vertex (unvisited/normal black circle, explored/blue circle, visited/orange circle) and back edge. Edge 2 → 1 will be discovered as a back edge as it is part of cycle 1 → 3 → 2 → 1 (similarly with Edge 6 → 4 as part of cycle 4 → 5 → 7 → 6 → 4).

X Esc
Назад PgUp
Вперед PgDn

We can use following simple recursive function to print out the path stored in array p. Possible follow-up discussion: Can you write this in iterative form? (trivial)

`method backtrack(u)  if (u == -1) stop  backtrack(p[u]);  output vertex u`

To print out the path from a source vertex s to a target vertex t in a graph, you can call O(V+E) DFS(s) (or BFS(s)) and then O(V) backtrack(t). Example: s = 0 and t = 4, you can call DFS(0) and then backtrack(4). Elaborate

X Esc
Назад PgUp
Вперед PgDn

If you are asked to test whether a vertex s and a (different) vertex t in a graph are reachable, i.e. connected directly (via a direct edge) or indirectly (via a simple, non cyclic, path), you can call the O(V+E) DFS(s) (or BFS(s)) and check if status[t] = visited.

Example 1: s = 0 and t = 4, run DFS(0) and notice that status[4] = visited.
Example 2: s = 0 and t = 7, run DFS(0) and notice that status[7] = unvisited.

X Esc
Назад PgUp
Вперед PgDn

We can enumerate all vertices that are reachable from a vertex s in an undirected graph (as the example graph shown above) by simply calling O(V+E) DFS(s) (or BFS(s)) and enumerate all vertex v that has status[v] = visited.

Example: s = 0, run DFS(0) and notice that status[{0,1,2,3,4}] = visited so they are all reachable vertices from vertex 0, i.e. they form one Connected Component (CC).

X Esc
Назад PgUp
Вперед PgDn

We can use the following pseudo-code to count the number of CCs:

`CC = 0for all u in V, set status[u] = unvisitedfor all u in V  if (status[u] == unvisited)    CC++ // we can use CC counter number as the CC label    DFS(u) // or BFS(u), that will flag its members as visitedoutput CC // the answer is 3 for the example graph above, i.e.// CC 0 = {0,1,2,3,4}, CC 1 = {5}, CC 2 = {6,7,8}`

You can modify the DFS(u)/BFS(u) code a bit if you want to use it to label each CC with the identifier of that CC.

X Esc
Назад PgUp
Вперед PgDn

Quiz: What is the time complexity of Counting the Number of CCs algorithm?

Trick question, the answer is none of the above, it is O(_____)
It is still O(V+E)
Calling O(V+E) DFS/BFS V times, so O(V*(V+E)) = O(V^2 + VE)

Discussion: Why?

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

There is another DFS (and also BFS) application that can be treated as 'simple': Performing Topological Sort(ing) of a Directed Acyclic Graph (DAG) — see example above.

Topological sort of a DAG is a linear ordering of the DAG's vertices in which each vertex comes before all vertices to which it has outbound edges.

Every DAG has at least one but possibly more topological sorts/ordering.

One of the main purpose of (at least one) topological sort of a DAG is for Dynamic Programming (DP) technique. For example, this topological sorting process is used internally in DP solution for SSSP on DAG.

X Esc
Назад PgUp
Вперед PgDn

We can use either the O(V+E) DFS or BFS to perform Topological Sort of a Directed Acyclic Graph (DAG).

The DFS version requires just one additional line compared to the normal DFS and is basically the post-order traversal of the graph. Try Toposort (DFS) on the example DAG.

The BFS version is based on the idea of vertices without incoming edge and is also called as Kahn's algorithm. Try Toposort (BFS/Kahn's) on the example DAG.

X Esc
Назад PgUp
Вперед PgDn

As of now, you have seen DFS/BFS and what it can solve (with just minor tweaks). There are a few more advanced applications that require more tweaks and we will let advanced students to explore them on their own:

1. Bipartite Graph Checker (DFS and BFS variants),
2. Finding Articulation Points (Cut Vertices) and Bridges of an Undirected Graph (DFS only),
3. Finding Strongly Connected Components (SCCs) of a Directed Graph (Tarjan's and Kosaraju's algorithms), and
4. 2-SAT(isfiability) Checker algorithms.

X Esc
Назад PgUp
Вперед PgDn

We can use the O(V+E) DFS or BFS (they work similarly) to check if a given graph is a Bipartite Graph by giving alternating color (orange versus blue in this visualization) between neighboring vertices and report 'non bipartite' if we ends up assigning same color to two adjacent vertices or 'bipartite' if it is possible to do such '2-coloring' process. Try DFS_Checker or BFS_Checker on the example Bipartite Graph.

Bipartite Graphs have useful applications in (Bipartite) Graph Matching problem.

Note that Bipartite Graphs are usually only defined for undirected graphs so this visualization will convert directed input graphs into its undirected version automatically before continuing. This action is irreversible and you may have to redraw the directed input graph again for other purposes.

X Esc
Назад PgUp
Вперед PgDn

We can modify (but unfortunately, not trivially) the O(V+E) DFS algorithm into an algorithm to find Cut Vertices & Bridges of an Undirected Graph.

A Cut Vertex, or an Articulation Point, is a vertex of an undirected graph which removal disconnects the graph. Similarly, a bridge is an edge of an undirected graph which removal disconnects the graph.

Note that this algorithm for finding Cut Vertices & Bridges only works for undirected graphs so this visualization will convert directed input graphs into its undirected version automatically before continuing. This action is irreversible and you may have to redraw the directed input graph again for other purposes. You can try to Find Cut Vertices & Bridges on the example graph above.

X Esc
Назад PgUp
Вперед PgDn

We can modify (but unfortunately, not trivially) the O(V+E) DFS algorithm into an algorithm to find Strongly Connected Components (SCCs) of a Directed Graph G.

An SCC of a directed graph G a is defined as a subgraph S of G such that for any two vertices u and v in S, vertex u can reach vertex v directly or via a path, and vertex v can also reach vertex u back directly or via a path.

There are two known algorithms for finding SCCs of a Directed Graph: Kosaraju's and Tarjan's. Both of them are available in this visualization. Try Kosaraju's Algorithm and/or Tarjan's Algorithm on the example directed graph above.

X Esc
Назад PgUp
Вперед PgDn

We also have the 2-SAT Checker algorithm. Given a 2-Satisfiability (2-SAT) instance in the form of conjuction of clauses: (clause1) ^ (clause2) ^ ... ^ (clausen) and each clause is in form of disjunction of up to two variables (vara v varb), determine if we can assign True/False values to these variables so that the entire 2-SAT instance is evaluated to be true, i.e. satisfiable.

It turns out that each clause (a v b) can be turned into four vertices a, not a, b, and not b with two edges: (not a → b) and (not b → a). Thus we have a Directed Graph. If there is at least one variable and its negation inside an SCC of such graph, we know that it is impossible to satisfy the 2-SAT instance.

After such directed graph modeling, we can run an SCC finding algorithm (Kosaraju's or Tarjan's algorithm) to determine the satisfiability of the 2-SAT instance.

X Esc
Назад PgUp
Вперед PgDn

Quiz: Which Graph Traversal Algorithm is Better?

Both are Equally Good
It Depends on the Situation
Always BFS
Always DFS

Discussion: Why?

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

There are lots of things that we can still do with just DFS and/or BFS...

X Esc
Назад PgUp
Вперед PgDn

There are interesting questions about these two graph traversal algorithms: DFS+BFS and variants of graph traversal problems, please practice on Graph Traversal training module (no login is required, but short and of medium difficulty setting only).

However, for registered users, you should login and then go to the Main Training Page to officially clear this module and such achievement will be recorded in your user account.

X Esc
Назад PgUp
Вперед PgDn

We also have a few programming problems that somewhat requires the usage of DFS and/or BFS: Kattis - reachableroads and Kattis - breakingbad.

Try to solve them and then try the many more interesting twists/variants of this simple graph traversal problem and/or algorithm.

You are allowed to use/modify our implementation code for DFS/BFS Algorithms:
dfs_cc.cpp/bfs.cpp
dfs_cc.java/bfs.java
dfs_cc.py/bfs.py
dfs_cc.ml/bfs.ml

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

As the action is being carried out, each step will be described in the status panel.

X Esc
Назад PgUp
Вперед PgDn

e-Lecture: The content of this slide is hidden and only available for legitimate CS lecturer worldwide. Drop an email to visualgo.info at gmail dot com if you want to activate this CS lecturer-only feature and you are really a CS lecturer (show your University staff profile).

X Esc
Назад PgUp
Вперед PgDn

Control the animation with the player controls! Keyboard shortcuts are:

Spacebar: play/pause/replay
Left/right arrows: step backward/step forward
-/+: decrease/increase speed
X Esc
Назад PgUp
Вперед PgDn

Note that if you notice any bug in this visualization or if you want to request for a new visualization feature, do not hesitate to drop an email to the project leader: Dr Steven Halim via his email address: stevenhalim at gmail dot com.

X Esc
Назад PgUp

Нарисовать Граф

Образцы Графов

Поиск вширину(s)

Поиск вширину(s)

Топологическая сортировка

Проверка Парного Графа

Разрезать вершину и связывающее ребро

Алгоритмы на Сильносвязных компонентах

Проверка 2-SAT

CP3 4.1

CP3 4.3

CP3 4.4 DAG

CP3 4.9

CP3 4.17 DAG

CP3 4.18 DAG, Bipartite

CP3 4.19 Bipartite

s =

Начать

s =

Начать

Версия с поиском вглубину

Версия с поиском вширину (алгоритм Кана)

Версия с поиском вглубину

Версия с поиском вширину

Алгоритм Косарайю

Алгоритм Тарьяна

Число условных выражений = , Число переменных =

Начать

#### О нас

VisuAlgo was conceptualised in 2011 by Dr Steven Halim as a tool to help his students better understand data structures and algorithms, by allowing them to learn the basics on their own and at their own pace.

VisuAlgo contains many advanced algorithms that are discussed in Dr Steven Halim's book ('Competitive Programming', co-authored with his brother Dr Felix Halim) and beyond. Today, some of these advanced algorithms visualization/animation can only be found in VisuAlgo.

Though specifically designed for National University of Singapore (NUS) students taking various data structure and algorithm classes (e.g. CS1010, CS1020, CS2010, CS2020, CS3230, and CS3230), as advocators of online learning, we hope that curious minds around the world will find these visualisations useful too.

VisuAlgo is not designed to work well on small touch screens (e.g. smartphones) from the outset due to the need to cater for many complex algorithm visualizations that require lots of pixels and click-and-drag gestures for interaction. The minimum screen resolution for a respectable user experience is 1024x768 and only the landing page is relatively mobile-friendly.

VisuAlgo is an ongoing project and more complex visualisations are still being developed.

The most exciting development is the automated question generator and verifier (the online quiz system) that allows students to test their knowledge of basic data structures and algorithms. The questions are randomly generated via some rules and students' answers are instantly and automatically graded upon submission to our grading server. This online quiz system, when it is adopted by more CS instructors worldwide, should technically eliminate manual basic data structure and algorithm questions from typical Computer Science examinations in many Universities. By setting a small (but non-zero) weightage on passing the online quiz, a CS instructor can (significantly) increase his/her students mastery on these basic questions as the students have virtually infinite number of training questions that can be verified instantly before they take the online quiz. The training mode currently contains questions for 12 visualization modules. We will soon add the remaining 8 visualization modules so that every visualization module in VisuAlgo have online quiz component.

Another active branch of development is the internationalization sub-project of VisuAlgo. We want to prepare a database of CS terminologies for all English text that ever appear in VisuAlgo system. This is a big task and requires crowdsourcing. Once the system is ready, we will invite VisuAlgo visitors to contribute, especially if you are not a native English speaker. Currently, we have also written public notes about VisuAlgo in various languages: zh, id, kr, vn, th.

#### Команда

Руководитель Проекта и Советник (июль 2011 по настоящее время)
Dr Steven Halim, Senior Lecturer, School of Computing (SoC), National University of Singapore (NUS)
Dr Felix Halim, Software Engineer, Google (Mountain View)

Научные Проекты Студентов Программы Бакалаврата 1 (Jul 2011-Apr 2012)
Koh Zi Chun, Victor Loh Bo Huai

Final Year Project/UROP students 1 (Jul 2012-Dec 2013)
Phan Thi Quynh Trang, Peter Phandi, Albert Millardo Tjindradinata, Nguyen Hoang Duy

Final Year Project/UROP students 2 (Jun 2013-Apr 2014)
Rose Marie Tan Zhao Yun, Ivan Reinaldo

Научные Проекты Студентов Программы Бакалаврата 2 (May 2014-Jul 2014)
Jonathan Irvin Gunawan, Nathan Azaria, Ian Leow Tze Wei, Nguyen Viet Dung, Nguyen Khac Tung, Steven Kester Yuwono, Cao Shengze, Mohan Jishnu

Final Year Project/UROP students 3 (Jun 2014-Apr 2015)
Erin Teo Yi Ling, Wang Zi

Final Year Project/UROP students 4 (Jun 2016-Dec 2017)
Truong Ngoc Khanh, John Kevin Tjahjadi, Gabriella Michelle, Muhammad Rais Fathin Mudzakir

List of translators who have contributed ≥100 translations can be found at statistics page.

Acknowledgements
Этот проект стал возможным благодаря щедрому гранту по Улучшению Процесса Обучения, выданного центром Национального университета Сингапура по Развитию Процесса Обучения (CDTL).

#### Условия использования

VisuAlgo is free of charge for Computer Science community on earth. If you like VisuAlgo, the only payment that we ask of you is for you to tell the existence of VisuAlgo to other Computer Science students/instructors that you know =) via Facebook, Twitter, course webpage, blog review, email, etc.

If you are a data structure and algorithm student/instructor, you are allowed to use this website directly for your classes. If you take screen shots (videos) from this website, you can use the screen shots (videos) elsewhere as long as you cite the URL of this website (http://visualgo.net) and/or list of publications below as reference. However, you are NOT allowed to download VisuAlgo (client-side) files and host it on your own website as it is plagiarism. As of now, we do NOT allow other people to fork this project and create variants of VisuAlgo. Using the offline copy of (client-side) VisuAlgo for your personal usage is fine.

Note that VisuAlgo's online quiz component is by nature has heavy server-side component and there is no easy way to save the server-side scripts and databases locally. Currently, the general public can only use the 'training mode' to access these online quiz system. Currently the 'test mode' is a more controlled environment for using these randomly generated questions and automatic verification for a real examination in NUS. Other interested CS instructor should contact Steven if you want to try such 'test mode'.

List of Publications

This work has been presented briefly at the CLI Workshop at the ACM ICPC World Finals 2012 (Poland, Warsaw) and at the IOI Conference at IOI 2012 (Sirmione-Montichiari, Italy). You can click this link to read our 2012 paper about this system (it was not yet called VisuAlgo back in 2012).

This work is done mostly by my past students. The most recent final reports are here: Erin, Wang Zi, Rose, Ivan.

Bug Reports or Request for New Features

VisuAlgo is not a finished project. Dr Steven Halim is still actively improving VisuAlgo. If you are using VisuAlgo and spot a bug in any of our visualization page/online quiz tool or if you want to request for new features, please contact Dr Steven Halim. His contact is the concatenation of his name and add gmail dot com.