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.
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+1 ∀i ∈ [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.
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.
要在图形绘制模式之间切换，请选择相应的标题。 我们有：
我们根据所选模式限制您可以绘制的图形类型。
您可以单击任何一个示例图形并可视化上图。
您还可以直接在可视化区域中绘制图形：
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.
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.
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.
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?
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
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
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.
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?
After storing our graph information into a graph DS, we can answer a few simple queries.
In an AM and AL, V is just the number of rows in the data structure that can be obtained in O(V) or even in O(1) — depending on the actual implementation.
Discussion: How to count V if the graph is stored in an EL?
PS: 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 our AM/AL/EL data structure) for the example graph shown above.
In an EL, E is just the number of its rows that can be counted in O(E). Note that depending on the need, we may store a bidirectional edge just once in the EL but on other case, we store both directed edges inside the EL.
In an 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) computation time as each vertex and each edge is only processed once.
Discussion: How to count E if the graph is stored in an AM?
PS: Sometimes this number is stored/maintained in a separate variable for efficiency, e.g. we can store that there are 8 undirected edges (in our AM/AL/EL data structure) for the example graph shown above.
In an AM, we need to loop through all columns of AM[u][j] ∀j ∈ [0..V-1] and report pair of (j, AM[u][j]) if AM[u][j] is not zero. This is O(V) — slow.
In an 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 is 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 an EL?
In an AM, we can simply check if AM[u][v] is non zero. This is O(1) — the fastest possible.
In an 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 an EL?
Quiz: So, what is the best graph data structure?
讨论: 为什么?
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, Matching, etc.