Lecture 10. Graphs Vertices, edges, paths, cycles Sparse and dense graphs Representations: adjacency matrices and adjacency lists Implementation notes

Transcription

1 Lecture 10 Graphs Vertices, edges, paths, cycles Sparse and dense graphs Representations: adjacency matrices and adjacency lists Implementation notes Reading: Weiss, Chapter 9 Page 1 of 24

2 Midterm exam Date and time: Thu May 7, during lecture time Place: lecture room Closed book, closed notes, no calculators Just bring something to write with, and picture ID Coverage: Lectures up to the exam; Programming assignments 1 and 2; corresponding readings Practice exam: available online Information about using PeerWise available on the class web pages Midterm reviews: Discussion section May 6 Page 2 of 24

3 Kinds of data structures You are familiar with these kinds of data structures: unstructured structures: sets linear, sequential structures: arrays, linked lists hierarchical structures: trees Now we will look at graphs Graphs consist of a collection of elements, called nodes or vertices a set of connections, called edges or links or arcs, between pairs of nodes Graphs are in general not hierarchical or sequential: there is no requirement for a distinguished root node or first node, no requirement that nodes have a unique parent or a unique successor, etc. Page 3 of 24

4 Why graphs? Trees are a generalization of lists (a list is just a special case of a tree)... Graphs are a generalization of of trees (a tree is just a special case of a graph)... So, graphs are very general structures and are very useful in many applications the set of machines on the internet, and network lines between them, form a graph the set of statements in a program, and flow of control between them, form a graph the set of web pages in the world, and HREF links between them, form a graph the set of transistors on a chip, and wires between them, form a graph the set of possible base sequences in a DNA gene, and mutations between them, form a graph the set of possible situations that can arise in solving a problem or playing a game, and moves that get you from one situation to another, form a graph et cetera... We will look at a formal definition of a graph, some ways of representing graphs, and some important algorithms on graphs Page 4 of 24

5 Graphs: some definitions A graph G = (V,E) consists of a set of vertices V and a set of edges E Each edge in E is a pair (v,w) such that v and w are in V. If G is an undirected graph, (v,w) in E means vertices v and w are connected by an edge in G. This (v,w) is an unordered pair If G is a directed graph, (v,w) in E means there is an edge going from vertex v to vertex w in G. This (v,w) is an ordered pair; there may or may not also be an edge (w,v) in E In a weighted graph, each edge also has a weight or cost c, and an edge in E is a triple (v,w,c) When talking about the size of a problem involving a graph, the number of vertices V and the number of edges E will be relevant Page 5 of 24

6 Graphs: an example Here is an unweighted directed graph: V0 V1 V2 V3 V4 V5 V6 V = { } V = E = { } E = Page 6 of 24

7 Graphs: more definitions A path in a graph G=(V,E) is a sequence of vertices v 1, v 2,..., v N in V such that (v i, v i+1 ) is in E for all i = 1,...,N-1. The length of a path is the number of edges in the path (might be zero) The weighted length of a path is the sum of the weights of the edges in the path A simple path is a path in which all the vertices are different (except the first and last can be the same) A cycle in a directed graph is a path of length >= 1 in which the first and last vertices are the same (in an undirected graph, the edges in a cycle must be distinct) A simple cycle is a cycle that is a simple path If a directed graph has no cycles, it is called a directed acyclic graph (DAG) Is the example graph on the previous page a DAG? Note: Every tree is a DAG, but not every DAG is a tree. Example: V1 V2 V3 V4 Page 7 of 24

8 Dense and sparse graphs If a directed graph has V vertices, how many edges can it have? The first vertex can have an edge to every vertex (including itself): V edges The second vertex can have an edge to every vertex (including itself): V edges... and so on for each of the V vertices; and all these edges are distinct So, the maximum total number of edges possible is E = V x V = V 2 A graph with close to V 2 edges is considered dense A graph with closer to V edges is considered sparse Page 8 of 24

9 Representing graphs There are two major techniques for representing graphs: Adjacency matrix Adjacency list Each of these has advantages and we will look at each Page 9 of 24

10 Adjacency matrices An adjacency matrix is a 2D array The [i][j] entry in the matrix encodes connectivity information between vertices i and j For an unweighted graph, the entry is 1 or true if there is an edge, 0 or false if there is no edge For a weighted graph, the entry is the weight of the edge, or infinity if there is no edge For an undirected graph, the matrix will be symmetric (or you could just use an upper-triangular matrix) There are V rows and V columns in an adjacency matrix, and so the matrix has V 2 entries This is space inefficient for sparse graphs Page 10 of 24

11 Adjacency matrix, an example Fill in this adjacency matrix for the example graph: Page 11 of 24

12 Adjacency lists An adjacency list representation uses, well, lists Each vertex in the graph has associated with it a list of the vertices adjacent to it That is, if (v j, v k ) is an edge in the graph, then v j s adjacency list contains (a reference to) v k For a weighted graph, the list entry would also contain the weight of the edge For an undirected graph, if v j s adjacency list contains v k, then v k s adjacency list should contain v j Using an adjacency list representation, each edge in a directed graph is represented by one item in one list; and there are as many lists as there are vertices Therefore the storage required is proportional to V + E, which is much better than V 2 for sparse graphs, and comparable to V 2 for dense graphs Page 12 of 24

13 Adjacency lists, an example Write down the adjacency lists to represent the example graph: V0: V1: V2: V3: V4: V5: V6: Page 13 of 24

14 Vertices, vertex names, and vertex indices In a graph application, the vertices of a graph may have names associated with them by the user as one example, vertices may correspond to cities, and be named with the city name Internally, within the implementation of the graph, it may be more convenient to be able to refer to a vertex using an integer number this number can be used as an index into an adjacency matrix, or an index into an array of adjacency lists, etc. To translate between the internal representation and one that makes sense to the user, you need some way to translate among names, vertices, and vertex index numbers So, in implementing a graph ADT, it is often convenient to have these (in addition to the adjacency matrix or adjacency lists): A dictionary data structure, e.g. a hash table, that associates names with vertex index numbers, and... An array or vector, that associates vertex numbers with vertices themselves, and... An instance variable in each vertex that stores the name associated with that vertex Page 14 of 24

15 Vertices, vertex names, and vertex indices: A design Internally within a Graph object, we will want a vertex to be uniquely identified by its name, or its integer index number, or by the identity of its corresponding Vertex object So, we will want a way to go from any one of those to any other. One way is with these mappings: Name via a Hashtable Index Index via a Vector Vertex Vertex via Vertex instance variable Name Note: only vertex names move through the public interface to the Graph; Vertex objects and indices are strictly part of the implementation Page 15 of 24

16 Graph, Vertex, and Edge Following a natural object-oriented design approach, the most important classes we will define are Graph, Vertex, and Edge A Graph will represent a weighted directed graph. It will permit a user to create an empty graph, and to add edges to the graph by specifying the names of the vertices connected by the edge, and the edge cost. Internally, it uses an adjacency list representation. In this framework, unweighted graphs can be handled by specifying 1 for edge weight; undirected graphs can be handled by having 2 parallel directed edges for each undirected edge A Graph object may also provide operations which implement useful graph algorithms such as shortest path and minimum spanning tree A Vertex will represent a vertex in a directed graph; it is used internally by the Graph class. A Vertex contains a String representation of its name, and its adjacency list (as a LinkedList). It may also contain other instance variables that are useful in implementing various graph operations. An Edge will represent an edge in a weighted directed graph; it is used internally by the Graph class. Edge objects are the elements in a Vertex s adjacency list. As such, an Edge only needs to contain an integer index of the vertex it is connecting to, and the cost of the edge. Page 16 of 24

17 An implementation of a Graph class We will look at parts of an implementation of a Graph class This implementation uses adjacency lists to represent a weighted directed graph The example Graph would be set up like this (the example is an unweighted directed graph, so costs are set equal to 1): Graph g = new Graph(); // create an empty Graph g.addedge("v0","v1",1); //edge from V0 to V1, cost 1 g.addedge("v1","v4",1); //edge from V1 to V4, cost 1 g.addedge("v1","v3",1); //edge from V1 to V3, cost 1 // etc. After the Graph is set up with all its edges, interesting algorithms can be run on the graph (more about these later) Page 17 of 24

18 An Edge class Instances of this class are elements of the adjacency lists in the Graph /** * This class defines the information in each * item in an adjacency list. */ class Edge { // Source vertex of edge is implicit public int dest; // Index of destination vertex of this edge public int cost; // Cost (weight) of this edge } public Edge( int d, int c ) { dest = d; cost = c; } Page 18 of 24

19 A Vertex class /** * This class defines the basic information * stored for each vertex. */ class Vertex { String name; // The name of this Vertex List<Edge> adj; // The adjacency list for this Vertex int dist; // variable for use by algorithms int prev; // variable for use by algorithms int scratch; // variable for use by algorithms } Vertex( String nm ) { name = nm; // name of this Vertex adj = new LinkedList<Edge>( ); // Start an empty adj list } Page 19 of 24

20 A Graph class /** * A class instances of which represent directed weighted graphs. */ public class Graph { // Maps vertex name to number private HashMap<String,Integer> vertexmap; // Vector of Vertexes in Graph private Vector<Vertex> vertexvec; private static final int NULL_VERTEX = -1; public Graph() { vertexvec = new Vector<Vertex>(); vertexmap = new HashMap<String,Integer>(); } Page 20 of 24

21 Adding an edge, given the names of its vertices and its cost /** * Add the edge ( source, dest, cost ) to the graph. */ public void addedge( String source, String dest, int cost ) { // get internal index of source, creating it if necessary Integer sourcenum = vertexmap.get(source); if (sourcenum == null) // new vertex, not seen before; add it sourcenum = addvertex(source); // get internal index of dest, creating it if necessary Integer destnum = vertexmap.get(dest); if (destnum == null) // new vertex, not seen before; add it destnum = addvertex(dest); } // now actually add the edge to the graph internaladdedge( sourcenum, destnum, cost ); Page 21 of 24

22 Adding a vertex, given its name /** * Add a vertex with the given name to the Graph, and * return its internal number as an Integer. * This involves adding entries to the Hashtable and vertex Vector. * PRE: vertexname is not already in the Graph */ private int addvertex( String vertexname ) { // get the next unused index; this will be the internal number int indx = vertexvec.size(); // create a new Vertex, put it at end of vertexvec, // where it will have index indx vertexvec.add( new Vertex(vertexName) ); // associate the vertex name and index in the vertexmap vertexmap.put( vertexname, indx ); } // return the internal vertex number return indx; Page 22 of 24

23 Adding an edge, cont d /** * Add an edge given internal index numbers of its vertices. * PRE: source and dest are indexes of Vertexes in vertexvec */ private void internaladdedge(int source, int dest, int cost) { // get the source Vertex, and add an edge to dest Vertex // to its adjacency list } vertexvec.get( source ).adj.add( new Edge (dest, cost) ); Page 23 of 24

24 Next time Algorithms on graphs Breadth first, depth first searches Shortest path in unweighted graphs Greedy algorithms Djikstra s algorithm for shortest path in weighted graphs Reading: Weiss, Chapter 9, 10 Page 24 of 24