Graph implementations :

Size: px

Start display at page:

Download "Graph implementations :"

Juniper McDaniel
5 years ago
Views:

1 Graphs

2 Graph implementations : The two standard ways of representing a graph G = (V, E) are adjacency-matrices and collections of adjacencylists. The adjacency-lists are ideal for sparse trees those where E is much less than V 2. By opposition, an adjacency-matrix may be preferrable when the graph is dense E is close to V 2 or if we need to rapidly determine if an edge exists. Note that for small graphs, the sheer simplicy of the adjacency matrix may make this approach preferrable over the adjacency list representation. Moreover, if the graph is unweighted, the boolean fields can be implemented using only one bit which requires far less memory then the words (32 bits) needed for the memory adressing (pointers) of the adjacency list objects.

3 Adjacency-list representation : The adjacency-list representation of a graph G = (V, E) consists of an array Adj of V lists, one for each vertex in V. For each u V, the adjacency list Adj[u] contains (pointers to) all the vertices v such that there is an edge (u, v) E. That is, Adj[u] consists of all the vertices adjacent to u in G. The vertices in each adjacency list are typically stored in an arbitrary order.... If G is a directed graph, the sum of the lengths of all the adjacency lists is E, since an edge of the form (u, v) is represented by having v appear in Adj[u]. If G is an undirected graph, the sum of the lengths of all the adjacency lists is 2 E, since if (u, v) is an undirected edge, then u appears in v s adjacency list and vice versa. Whether a graph is directed or not, the adjacency-list representation has the desirable property that the amount of memory it requires is O(max(V, E)) = O(V +E). Adjacency lists can readily be adapted to represent weighted graphs, that is, graphs for which each edge has an associated weight, typically given by a weight function w : E R. For example, let G = (V, E) be a weighted graph with weight function w. The weight w(u, v) of the edge (u, v) E is simply stored with vertex v in u s adjacency list. The adjacency-list representation is quite robust in that it can be modified to support many other graph variants.

4 Adjacency-matrix representation: Unfortunately, one of the biggest drawbacks of the adjacency-list representation is that there is no quicker way to determine if a given edge (u, v) exists other then traversing the list associated to u. For the adjacency-matrix representation of a graph G = (V, E), we assume that the vertices are numbered 1, 2,..., V in some arbitrary manner. The adjacency-matrix representation of a graph G then consists of a V V matrix A = (a ij ) such that... a ij = { 1 if (i, j) E, 0 otherwise The adjacency matrix of a graph requires θ(v 2 ) memory, independent of the number of edges in the graph.... We define the transpose of a matrix A = (a ij ) to be the matrix A T = (a T ij ), given by at ij = a ji. Since in an undirected graph, (u, v) and (v, u) represent the same edge, the adjacency matrix A of an undirected graph is its own transpose : A = A T. In some applications, it pays to store only the entries on and above the diagonal of the adjacency matrix, thereby cutting the memory needed to store the graph almost in half. ref # 4, chap. 23

5 Search : Graph searching algorithms are usually classified in one of two categories : breadth-first search and depth-first search. Given a graph G = (V, E) and a distinguished source vertex s, breadth-first search systematically explores the edges of G to discover every vertex that is reachable from s. It is so named because it expands the limit of known discovered vertices uniformely accross the breadth of the current frontier. That is, the algorithm discovers all vertices at distance k from the source s before discovering those at distance k + 1. Depth-first search however attempts to search a path as far out as possible before starting on the other edges. The algorithms we saw for the tree traversals were example of depth first search. In depth-first search, edges are explored out of the most recently discovered vertex v that still has unexplored edges leaving it. When all of v s edges have been explored, the search backtracks to explore edges leaving the vertex from which v was discovered. This process continues until we have discovered all the vertices that are reachable from the original source vertex. If any undiscovered vertices remain, then one of them is selected as a new source and the search is repeated from that source. This entire process is repeated until all vertices are discovered. ref # 4, p. 477

6 Breadth-first search : Breadth-first search allows us to easily determine all the vertices reachable from the source vertex s. By the end of its execution, it will have produced a breadth-first tree with s for root. The most interesting property of this tree is that given a vertex v, the path from s to v indicated by the tree corresponds to the shortest path in the graph between these two vertices. The algorithm we will present proceeds by coloring all the vertices. Given any vertex, it originally starts as white, but will evolve to gray when discovered and then black when all of its own adjacent vertices have been discovered. Therefore a gray vertex may have adjacent white vertices, which is impossible for a black vertex. The procedure here presented starts the construction of the tree with only the root vertex s. Should a white vertex v be discovered while scanning the list of adjacent vertices of an already discovered vertex u, the vertex v and the edge (u, v) are added to the tree. We say that u is the predecessor or parent of v in the breadth-first tree.

7 function BF S(G, s) for each vertex u V [G] {s} do color[u] W HIT E d[u] π[u] NIL color[s] GRAY d[s] 0 π[s] NIL Q {s} while Q do u head[q] for each v Adj[u] do if color[v] = W HIT E then color[v] GRAY d[v] d[u] + 1 π[v] u Enqueue(Q, v) Dequeue(Q) color[u] BLACK color[u] color of vertex u π[u] predecessor parent of u d[u] distance from u to the source s

8 The procedure BFS builds a breadth-first tree as it searches the graph. The tree is represented by the π field in each vertex. More formally, for a graoh G = (V, E) with source s, we define the predecessor subgraph of G as G π = (V π, E π ), where V π = {v C : π[v] NIL} {s} and E π = {(π[v], v) E : v V π {s}}. The predecessor subgraph of G π is a breadth-first tree if V π consists of the vertices reachable from s to v in G π that is also a shortest path from s to v in G. A breadth-first tree is in fact a tree, since it is connected and E π = V π 1. The edges in E π are called tree edges. ref # 4 p.475

9 Depth-first search : As in the breadth-first search algorithm, depth-first keeps track of all the vertices v it discovers when visiting the edges of an already discovered vertex u by setting the field π[v] to u. Note that in the depth-first search approach, the predecessor subgraph may be composed of a forest of trees since the search may be repeated from multiple sources. The predecessor subgraoh of a depth-first search is therefore sligthly different from that of a breadth-first search: G π = (V, E π ) E π = {(π[v], v) : v V and π[v] NIL} As in the breadth-first search, vertices are colored either white while undiscovered, grey when discovered and black when all of the adjacent vertices have been visited.

10 function DF S(G) for each vertex u V [G] do color[u] W HIT E π[u] NIL time 0 for each vertex u V [G] do if color[u] = W HIT E then DF S V isit(u) function DF S V isit(u) color[u] GRAY d[u] time time + 1 for each v Adj[u] do if color[v] = W HIT E then π[v] u DF S V isit(v) color[u] BLACK f[u] time time + 1 color[u] color of vertex u π[u] predecessor parent of u d[u] time of discovery of vertex u f[u] time when the algorithm finishes at node u

Elementary Graph Algorithms

Elementary Graph Algorithms Graphs Graph G = (V, E)» V = set of vertices» E = set of edges (V V) Types of graphs» Undirected: edge (u, v) = (v, u); for all v, (v, v) E (No self loops.)» Directed: (u, v)