7    VisuAlgo.net / /graphds Login Undirected/Unweighted U/W D/U D/W
Exploration Mode ▿

A graph is made up of vertices/nodes and edges/lines that connect those vertices.


A graph may be undirected (or bidirectional), meaning that there is no distinction between the two vertices associated with each edge, or its edges may be directed from one vertex to another but not necessarily in the other direction.


A graph can be weighted by assigning a weight to each edge, which represent numerical values associated with that connection, or a graph can be unweighted (either all edges have unit weight 1 or all edges have the same constant weight).


Remarks: By default, we show e-Lecture Mode for first time (or non logged-in) visitor.
Please login if you are a repeated visitor or register for an (optional) free account first.

X Esc
Next PgDn

Most graph problems that we discuss in VisuAlgo involves simple graphs.


In a simple graph, there is no (self-)loop edge (an edge that connects a vertex with itself) and no multiple/parallel edges (edges between the same pair of vertices). In another word: There can only be up to one edge between a pair of distinct vertices.


The number of edges E in a simple graph can only range from 0 to O(V2).


Graph algorithms on simple graphs are easier than on non-simple graphs.


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
Prev PgUp
Next PgDn

An undirected edge e: (u, v) is said to be incident with its two end-point vertices: u and v and two vertices are called adjacent (or neighbor) if they are incident with a common edge. For example, edge (0, 2) is incident to vertices 0+2 and vertices 0+2 are adjacent.


Two edges are called adjacent if they are incident with a common vertex. For example, edge (0, 2) and (2, 4) are adjacent.


The degree of a vertex v in an undirected graph is the number of edges incident with v. A vertex of degree 0 is called an isolated vertex. For example, vertex 0/2/6 has degree 2/3/1, respectively.


A subgraph G' of a graph G is a (smaller) graph that contains subset of vertices and edges of G. For example, a triangle {0, 1, 2} is a subgraph of the currently displayed graph.


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
Prev PgUp
Next PgDn

A path (of length n) in an (undirected) graph G is a sequence of vertices {v0, v1, ..., vn-1, vn} such that there is an edge between vi and vi+1i ∈ [0..n-1] along the path.


If there is no repeated vertex along the path, we call such path as a simple path.


For example, {0, 1, 2, 4, 5} is one simple path in the currently displayed graph.

X Esc
Prev PgUp
Next PgDn

An undirected graph G is called connected if there is a path between every pair of distinct vertices of G. For example, the currently displayed graph is not a connected graph.


An undirected graph C is called a connected component of the undirected graph G if 1). C is a subgraph of G; 2). C is connected; 3). no connected subgraph of G has C as a subgraph and contains vertices or edges that are not in C (i.e. C is the maximal subgraph that satisfies the other two criteria).


For example, the currently displayed graph have {0, 1, 2, 3, 4} and {5, 6} as its two connected components.

X Esc
Prev PgUp
Next PgDn

In a directed graph, some of the terminologies mentioned earlier have small adjustments.


If we have a directed edge e: (uv), we say that v is adjacent to u but not vice versa. For example, 1 is adjacent to 0 but 0 is not adjacent to 1.


In a directed graph, we have to further differentiate the degree of a vertex v into in-degree and out-degree. The in-degree/out-degree is the number of edges coming-into/going-out-from v, respectively. For example, vertex 1 has in-degree/out-degree of 2/1, respectively.


In a directed graph, we define the concept of Strongly Connected Component (SCC). In the currently displayed directed graph, we have {0}, {1, 2, 3}, and {4, 5, 6, 7} as its three SCCs.

X Esc
Prev PgUp
Next PgDn

A cycle is a path that starts and ends with the same vertex.


An acyclic graph is a graph that contains no cycle.


In an undirected graph, each undirected graph causes a trivial cycle although we usually will not classify it as a cycle.


A directed graph that is also acyclic has a special name: Directed Acyclic Graph (DAG), as shown above.


There are interesting algorithms that we can perform on acyclic graphs that will be explored in this visualization page and in other graph visualization pages in VisuAlgo.

X Esc
Prev PgUp
Next PgDn

A graph with specific properties involving its vertices and/or edges structure can be called with its specific name, like Tree (like the one currently shown), Complete Graph, Bipartite Graph, Directed Acyclic Graph (DAG), and also the less frequently used: Line Graph, Star Graph, Wheel Graph, etc.


In this visualization, we will highlight the first four special graphs later.

X Esc
Prev PgUp
Next PgDn

Graph appears very often in various form in real life. The most important part in solving graph problem is thus the graph modeling part, i.e. reducing the problem in hand into graph terminologies: vertices, edges, weights, etc.

X Esc
Prev PgUp
Next PgDn

Social Network: Vertices can represent people, Edges represent connection between people (usually undirected and unweighted).


For example, see the undirected graph that is currently shown. This graph shows 7 vertices (people) and 8 edges (connection/relationship) between them. Perhaps we can ask questions like these:

  1. Who is/are the friend(s) of people 0?
  2. Who has the most friend(s)?
  3. Is there any isolated people with no friend?
  4. Is there a common friend between two strangers people 3 and people 5?
  5. Etc...
X Esc
Prev PgUp
Next PgDn

Transportation Network: Vertices can represent stations, edges represent connection between stations (usually weighted).


For example, see the directed weighted graph that is currently shown. This graph shows 5 vertices (stations/places) and 6 edges (connections/roads between stations, with positive weight travelling times as indicated). Suppose that we are driving a car. We can perhaps ask what is the path to take to go from station 0 to station 4 so that we reach station 4 using the least amount of time?


Discussion points: Think of a few real life scenarios which can be modelled as a graph.

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

To toggle between the graph drawing modes, select the respective header. We have:

  1. U/U = Undirected/Unweighted,
  2. U/W = Undirected/Weighted,
  3. D/U = Directed/Unweighted, and
  4. D/W = Directed/Weighted.

We restrict the type of graphs that you can draw according to the selected mode.

X Esc
Prev PgUp
Next PgDn

You can click any one of the example graphs and visualize the graph above.


You can also draw a graph directly in the visualization area:

  1. Click on empty space to add vertex,
  2. Click a vertex, hold, drag the drawn edge to another vertex, and drop it there to add an edge (PS: This action is not available for mobile users; you need a mouse),
  3. Select a vertex/edge and press 'Delete' key to delete that vertex/edge,
  4. Select an edge and press 'Enter' to change the weight of that edge [0..99],
  5. Press and hold 'Ctrl', then you can click and drag a vertex around.
X Esc
Prev PgUp
Next PgDn

We limit the graphs discussed in VisuAlgo to be simple graphs. Refer to its discussion in this slide.


We also limit the number of vertices that you can draw on screen to be up to 10 vertices, ranging from vertex 0 to vertex 9. This, together with the simple graph constraint above, limit the number of undirected/directed edges to be 45/90, respectively.

X Esc
Prev PgUp
Next PgDn

All example graphs can be found here.


For now, we provide at least two example graphs per category (U/U, U/W, D/U, D/W).


Note that after loading one of these example graphs, you can further modify the currently displayed graph to suit your needs.

X Esc
Prev PgUp
Next PgDn

Tree, Complete, Bipartite, Directed Acyclic Graph (DAG) are properties of special graphs. As you modify the graph in the visualization/drawing area above, these properties are checked and updated instantly.


There are other less frequently used special graphs: Line Graph, Star Graph, Wheel Graph, etc, but they are not currently auto-detected in this visualization when you draw them.

X Esc
Prev PgUp
Next PgDn

Tree is a connected graph with V vertices and E = V-1 edges, acyclic, and has one unique path between any pair of vertices. Usually a Tree is defined on undirected graph.


An undirected Tree (see above) actually contains trivial cycles (caused by its bidirectional edges) but it does not contain non-trivial cycle. A directed Tree is clearly acyclic.


As a Tree only have V-1 edges, it is usually considered a sparse graph.


We currently show our U/U: Tree example. You can go to 'Exploration Mode' and draw your own trees.

X Esc
Prev PgUp
Next PgDn

Not all Trees have the same graph drawing layout of having a special root vertex at the top and leaf vertices (vertices with degree 1) at the bottom. The (star) graph shown above is also a Tree as it satisfies the properties of a Tree.


Tree with one of its vertex designated as root vertex is called a rooted Tree.


We can always transform any Tree into a rooted Tree by designating a specific vertex (usually vertex 0) as the root, and run a DFS or BFS algorithm from the root.

X Esc
Prev PgUp
Next PgDn

In a rooted tree, we have the concept of hierarchies (parent, children, ancestors, descendants), subtrees, levels, and height. We will illustrate these concepts via examples as their meanings are as with real-life counterparts:

  1. The parent of 0/1/7/2/4 are none/0/0/1/3, respectively,
  2. The children of 0/1/7 are {1,7}/{2,3,6}/{8,9}, respectively,
  3. The ancestors of 4/8 are {3,1,0}/{7,0}, respectively,
  4. The descendants of 1/7 are {2,3,4,5,6}/{8,9}, respectively,
  5. The subtree rooted at 1 includes 1, its descendants, and all associated edges,
  6. Level 0/1/2/3 members are {0}/{1,7}/{2,3,6,8,9}/{4,5}, respectively,
  7. The height of this rooted tree is its maximum level = 3.
X Esc
Prev PgUp
Next PgDn

For rooted tree, we can also define additional properties:


A binary tree is a rooted tree in which a vertex has at most two children that are aptly named: left and right child. We will frequently see this form during discussion of Binary Search Tree and Binary Heap.


A full binary tree is a binary tree in which each non-leaf (also called the internal) vertex has exactly two children. The binary tree shown above fulfils this criteria.


A complete binary tree is a binary tree in which every level is completely filled, except possibly the last level may be filled as far left as possible. We will frequently see this form especially during discussion of Binary Heap.

X Esc
Prev PgUp
Next PgDn

Complete graph is a graph V vertices and E = V*(V-1)/2 edges (or E = O(V2)), i.e. there is an edge between any pair of vertices. Usually a Complete graph is denoted with KV.


Complete graph is the most dense simple graph.


We currently show our U/W: K5 example. You can go to 'Exploration Mode' and draw your own complete graphs (a bit tedious for larger V though).

X Esc
Prev PgUp
Next PgDn

Bipartite graph is an undirected graph with V vertices that can be partitioned into two disjoint set of vertices of size m and n where V = m+n. There is no edge between members of the same set. Bipartite graph is also free from odd-length cycle.


We currently show our U/U: Bipartite example. You can go to 'Exploration Mode' and draw your own bipartite graphs.


A Bipartite Graph can also be complete, i.e. all m vertices from one disjoint set are connected to all n vertices from the other disjoint set. When m = n = V/2, such Complete Bipartite Graphs also have E = O(V2).

X Esc
Prev PgUp
Next PgDn

Directed Acyclic Graph (DAG) is a directed graph that has no cycle, which is very relevant for Dynamic Programming (DP) techniques.


Each DAG has at least one Topological Sort/Order which can be found with a simple tweak to DFS/BFS Graph Traversal algorithm. DAG will be revisited again in DP technique for SSSP on DAG.


We currently show our D/W: Four 0→4 Paths example. You can go to 'Exploration Mode' and draw your own DAGs.

X Esc
Prev PgUp
Next PgDn

There are many ways to store graph information into a graph data structure. In this visualization, we show three graph data structures: Adjacency Matrix, Adjacency List, and Edge List — each with its own strengths and weaknesses.

X Esc
Prev PgUp
Next PgDn

Adjacency Matrix (AM) is a square matrix where the entry AM[i][j] shows the edge's weight from vertex i to vertex j. For unweighted graphs, we can set a unit weight = 1 for all edge weights. An 'x' means that that vertex does not exist (deleted).


We simply use a C++/Java native 2D array of size VxV to implement this data structure.

X Esc
Prev PgUp
Next PgDn

Space Complexity Analysis: An AM unfortunately requires a big space complexity of O(V2), even when the graph is actually sparse (not many edges).


Discussion: Knowing the large space complexity of AM, when is it beneficial to use it? Or is AM always an inferior graph data structure and should not be used at all times?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

Adjacency List (AL) is an array of V lists, one for each vertex (usually in increasing vertex number) where for each vertex i, AL[i] stores the list of i's neighbors. For weighted graphs, we can store pairs of (neighbor vertex number, weight of this edge) instead.


We use a Vector of Vector pairs (for weighted graphs) to implement this data structure.
In C++: vector<vector<pair<int,int>>> AL;
In Java: Vector < Vector < IntegerPair > > AL;
// class IntegerPair in Java is like pair<int,int> in C++, next slide

X Esc
Prev PgUp
Next PgDn
class IntegerPair implements Comparable<IntegerPair> {
Integer _f, _s;
public IntegerPair(Integer f, Integer s) { _f = f; _s = s; }
public int compareTo(IntegerPair o) {
if (!this.first().equals(o.first())) // this.first() != o.first()
return this.first() - o.first(); // is wrong as we want to
else // compare their values,
return this.second() - o.second(); // not their references
}
Integer first() { return _f; }
Integer second() { return _s; }
}
// IntegerTriple is similar to IntegerPair, just that it has 3 fields
X Esc
Prev PgUp
Next PgDn

We use pairs as we need to store pairs of information for each edge: (neighbor vertex number, edge weight) where weight can be set to 0 or unused for unweighted graph.


We use Vector of Pairs due to Vector's auto-resize feature. If we have k neighbors of a vertex, we just add k times to an initially empty Vector of Pairs of this vertex (this Vector can be replaced with Linked List).


We use Vector of Vectors of Pairs for Vector's indexing feature, i.e. if we want to enumerate neighbors of vertex u, we use AL[u] (C++) or AL.get(u) (Java) to access the correct Vector of Pairs.

X Esc
Prev PgUp
Next PgDn

Space Complexity Analysis: AL has space complexity of O(V+E), which is much more efficient than AM and usually the default graph DS inside most graph algorithms.


Discussion: AL is the most frequently used graph data structure, but discuss several scenarios when AL is actually not the best graph data structure?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

Edge List (EL) is a collection of edges with both connecting vertices and their weights. Usually, these edges are sorted by increasing weight, e.g. part of Kruskal's algorithm for Minimum Spanning Tree (MST) problem. However in this visualization, we sort the edges based on increasing vertex 1 and if ties, by increasing vertex 2. Note that Bidirectional edges in undirected/directed graph are listed once/twice, respectively.


We use a Vector of triples to implement this data structure.
In C++: vector<tuple<int,int,int>> EL;
In Java: Vector<IntegerTriple> EL;
// class IntegerTriple in Java is like tuple<int,int,int> in C++

X Esc
Prev PgUp
Next PgDn

Space Complexity Analysis: EL has space complexity of O(E), which is much more efficient than AM and as efficient as AL.


Discussion: Elaborate the potential usage of EL other than for Kruskal's algorithm for Minimum Spanning Tree (MST) problem!

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

After storing our graph information into a graph DS, we can answer a few simple queries.

  1. Counting V,
  2. Counting E,
  3. Enumerating neighbors of a vertex u,
  4. Checking the existence of edge (u, v), etc.
X Esc
Prev PgUp
Next PgDn

In AM and AL, V is just the number of rows that can be counted in O(V).


Sometimes this number is stored/maintained in a separate variable so that we do not have to re-compute this every time — especially if the graph never/rarely changes after it is created, hence O(1) performance, e.g. we can store that there are 7 vertices in the example graph shown above.


Discussion: How to count V if the graph is stored in EL (assume that we do not use separate variable for this)?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

In EL, E is just the number of rows that can be counted in O(E). Note that depending on the need, we may store a bidirectional edge just once in EL but on other case, we store both directed edges inside EL.


In AL, E can be found by summing the length of all V lists and divide the final answer by 2 (for undirected graph). This requires O(V+E) to be computed as each vertex and each edge is only processed once.


Sometimes this number is stored/maintained in a separate variable for efficiency, e.g. we can store that there are 8 undirected edges in the example graph shown above.


Discussion: How to count E if the graph is stored in AM?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

In AM, we need to loop through all columns of AM[u][j] ∀j ∈ [0..V-1] and report AM[u][j] that is not zero. This is O(V) — slow.


In AL, we just need to scan AL[u]. If there are only k neighbors of vertex u, then we just need O(k) to enumerate them — this is called an output-sensitive time complexity and already the best possible.


We usually list the neighbors in increasing vertex number. For example, neighbors of vertex 1 in the example graph above are {0, 2, 3}, in that increasing vertex number order.


Discussion: How to do this if the graph is stored in EL?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

In AM, we can simply check if AM[u][v] is non zero. This is O(1) — the fastest possible.


In AL, we have to check whether AL[u] contains vertex v or not. This is O(k) — slower.


For example, edge (2, 4) exists in the example graph above but edge (2, 6) does not exist.


Note that if we have found edge (u, v), we can also access and/or update its weight.


Discussion: How to do this if the graph is stored in EL?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

Quiz: So, what is the best graph data structure?

Adjacency Matrix
Edge List
It Depends
Adjacency List


Discussion: Why?

X Esc
Prev PgUp
Next 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
Prev PgUp
Next PgDn

You have reached the end of the basic stuffs of this relatively simple Graph Data Structures and we encourage you to explore further in the Exploration Mode by drawing your own graphs.


However, we still have a few more interesting Graph Data Structures challenges for you that are outlined in this section.


Note that graph data structures are usually just the necessary but not sufficient part to solve the harder graph problems like MST, SSSP, Max Flow, etc.

X Esc
Prev PgUp
Next PgDn

For a few more interesting questions about this data structure, please practice on Graph Data Structures 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
Prev PgUp
Next PgDn

Try to solve two basic programming problems that somewhat requires the usage of graph data structure without any fancy graph algorithms: UVa 10895 - Matrix Transpose and Kattis - flyingsafely.

X Esc
Prev PgUp
Next 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
Prev PgUp
• Tree? No • Complete? No • Bipartite? No • DAG? No
Adjacency Matrix
012
0010
1101
2010
Adjacency List
0: 1
1: 02
2: 1
Edge List
0: 01
1: 12

U/U: CP3 Fig 2.4

U/U: CP3 Fig 2.4, disjoint

U/U: Tree

U/U: Binary Tree

U/U: Bipartite

U/U: CP2.5C - Knight Jump

U/W: CP3 Fig 4.10

U/W: K5 (Complete)

U/W: Star

D/U: CP3 Fig 4.4

D/U: CP3 Fig 4.8

D/U: Cyclic

D/W: CP3 Fig 4.26B*

D/W: Four 0→4 Paths

>
About Team Terms of use

About

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.

Team

Project Leader & Advisor (Jul 2011-present)
Dr Steven Halim, Senior Lecturer, School of Computing (SoC), National University of Singapore (NUS)
Dr Felix Halim, Software Engineer, Google (Mountain View)

Undergraduate Student Researchers 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

Undergraduate Student Researchers 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
This project is made possible by the generous Teaching Enhancement Grant from NUS Centre for Development of Teaching and Learning (CDTL).

Terms of use

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.