Podcast Ch26a Title: Representing Graphs Description: Adjacency matrix; adjacency list; VertexInfo class; vertex map; exploring the adjacency list Participants: Barry Kurtz (instructor); John Helfert and Tobie Williams (students) Textbook: Data Structures for Java; William H. Ford and William R. Topp

Representing Graphs Adjacency matrix representation of a graph uses a matrix whose entries give the weight of an edge (vi,vj) or 0 if there is no edge from vi to vj.

Draw the adjacency matrix for the following graph G.

Use the following digraph; a assume the weights are all 1. (a) Identify the adjacency matrix for the graph. (i) 0 1 1 0 1 (ii) 0 1 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 (iii) 0 1 0 0 0 (iv) 0 1 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1

Representing Graphs (concluded) An Adjacency list representation of a graph includes the vertex with the list of its neighbors.

Give the adjacency list representation of the graph. Vertex Edges

Edge Class class Edge { // index of the destination vertex in the // ArrayList vInfo of vertex properties public int dest; // weight of this edge public int weight; public Edge(int dest, int weight) { this.dest = dest; this.weight = weight; } public boolean equals(Object obj) { return ((Edge)obj).dest == this.dest;

Representing Vertex Information The VertexInfo class has a reference to the vertex value, the in-degree of the vertex, a list of edges originating at the vertex and other information used by graph algorithms.

VertexInfo Class // maintains vertex properties, including // its set of Edges class VertexInfo<T> { // vertex reference back to the vertex in the map public T vertex; // list of Edge objects (adjacent vertices) // for the current vertex public LinkedList<Edge> edgeList; // maintains the in-degree of the vertex public int inDegree; // indicates whether the object currently // represents a vertex public boolean occupied;

VertexInfo Class (continued) // indicates vertex color for use in algorithms // that traverse the vertices of a Graph public VertexColor color; // available to algorithms for storing relevant // data values public int dataValue; // available to Graph algorithms; holds parent // which is a vertex that has an edge terminating // in the current vertex public T parent;

VertexInfo Class (concluded) // constructor creates an object with initial // values for the vertex, edgeList, inDegree, // and occupied fields public VertexInfo(T v) { vertex = v; edgeList = new LinkedList<Edge>(); inDegree = 0; occupied = true; }

VertexColor Class The VertexColor class maintains the color of a vertex. The colors of WHITE, GRAY, and BLACK are values of the enumerated type. public enum VertexColor { WHITE, GRAY, BLACK }

Vertex Map & VertexInfo ArrayList The vertex map contains key‑value pairs where the key is a reference to the vertex and the value is an index into an ArrayList of VertexInfo objects.

Vertex Map & VertexInfo ArrayList

For the following graph G, assume that the vInfo index of A: 0. B: 1 For the following graph G, assume that the vInfo index of A: 0 B: 1 C: 2 D: 3 Demonstrate the graph class representation for G in the map vtxMap and the array list vInfo containing a list of VertexInfo object. In vtxMap, fill-in the key and value components of the key-value pair. In vInfo, fill-in the in-degree and the edge set for each vertex. Recall that each entry of the edge list is of the form {dest vInfo index, weight}. For instance, the edge (A, C) is represented in the edge set of A by {2, 3}.

Exploring the Adjacency List A VertexInfo object allows access to all the neighbors of the vertex. VertexInfo<T> vtxInfo = vInfo.get(i); // declare an iterator for edgeList and position it // at the first element in the adjacency list Iterator<Edge> iter = vtxInfo.edgeList.iterator(); // extract the first element and output its weight Edge e = iter.next(); System.out.println(e.weight); // use the dest field to access the vInfo element // that corresponds to the adjacent vertex; the // index of the element is e.dest; // output the name of the vertex VertexInfo<T> edgeVtxInfo = vInfo.get(e.dest); System.out.println(edgeVtxInfo.vertex);

Exploring the Adjacency List of a Vertex (continued) Let us look at a code segment that scans the adjacency list looking for the edge of minimum weight. In order to output the edge, we must maintain the vInfo index of the destination vertex. // declare variables for the minimum dest index and // minimum weight int minDest, minWeight = Integer.MAX_VALUE; // VertexInfo objects for elements in vInfo; // current vertex element in vInfo is vtxInfo; // vInfo element for a neighbor is edgeVtxInfo VertexInfo<T> vtxInfo = null, edgeVtxInfo = null; ...

Exploring the Adjacency List of a Vertex (continued) // iterator scans adjacency list for current vertex Iterator<Edge> iter = vtxInfo.edgeList.iterator(); while (iter.hasNext) { // extract next element (Edge object) from // adjacency list Edge e = iter.next(); // update if new minimum weight is discovered if (e.weight < minWeight) minWeight = e.weight; minDest = e.dest; }

Exploring the Adjacency List of a Vertex (continued) // output the edge that has minimum weight; // first get the corresponding vInfo element // and then access the vertex field edgeVtxInfo = vInfo.get(minDest); System.out.println("Edge (" + vtxInfo.vertex + ", " + edgeVtxInfo.vertex + ") has weight + edgeVtxInfo.weight);

The occupied Field Occupied field of a VertexInfo object indicates if the object corresponds to an existing vertex entry in the map. for (i = 0; i < vInfo.size(); i++) { VertexInfo<T> vtxInfo = vInfo.get(i); if (vtxInfo.occupied) < vInfo element corresponds to an actual vertex> }