Graphs. The ultimate data structure. graphs 1

Size: px

Start display at page:

Download "Graphs. The ultimate data structure. graphs 1"

Egbert Webb
5 years ago
Views:

1 Graphs The ultimate data structure graphs 1

2 Definition of graph Non-linear data structure consisting of nodes & links between them (like trees in this sense) Unlike trees, graph nodes may be completely unordered, or may be linked in any order suited to the particular application graphs 2

3 Undirected graphs Simplest form of graph Set of nodes (vertices -- one node is a vertex) and set of links between them (edges) Either or both sets may be empty Each edge connects two vertices; as the name implies, neither vertex is considered to be a point of origin or a point of destination An edge may also connect a vertex to itself graphs 3

4 Example graph v0 e0 v3 e2 v1 e1 v4 e4 v1 v3 v0 e0 e1 e2 e4 v2 v2 This graph has 5 vertices and 4 edges; a graph is defined by which vertices are connected, and which edges connect them v4 This is the same graph, even though its shape is different graphs 4

5 Directed graphs Each edge has an orientation, or direction One vertex connected by the edge is the source, while the other is the target Directed graphs are diagrammed like undirected graphs, except the edges are represented by arrows instead of lines graphs 5

6 Directed graph example Each arrow represents the direction of the edge; to get from point a to point f, you must pass through c, d and b c (in that order), but to get from f to a requires only going through b (by the shortest route) e a d b f graphs 6

7 Directed graph application examples Route diagrams for airline routes Course pre- and co-requisites Program flow charts Programming language syntax diagrams graphs 7

8 Modeling with graphs - examples Niche overlap graph in ecology: each species represented by vertex undirected edge connects 2 vertices if the species compete Precedence graph: vertices represent statements in a computer program directed edge between vertices means 1st statement must be executed before 2nd 8

9 Bipartite Graphs A simple graph G is called bipartite if its vertex set V can be partitioned into 2 disjoint non-empty sets V1 and V2 such that: every edge connects a vertex in V1 with a vertex in V2 no edge connects 2 vertices in V1 or in V2 9

10 Example: lining up 1st graders Cate John Mary Mark Mary Ann Terry Mary Pat Tim Marie Jimmy 10

11 Examples Graph at left is not bipartite; to divide into 2 sets, one set must include 2 vertices and to be bipartite, those vertices must not be connected But every vertex in this graph is connected to 2 others This graph, on the other hand, is bipartite; the two sets are V1 = {v1, v3, v5} and V2 = {v2, v4, v6} Note that the definition doesn t say a vertex in one set can t connect to more than one vertex in the other - only that each in one must connect to one in the other, and no vertex in a set can connect to a vertex in the same set 11

12 Examples: are they bipartite? 12

13 Subgraph Graph obtained by removing vertices and their associated edges from a larger graph; more formally: Subgraph of G=(V,E) is H=(W,F) where W V and F E 13

14 Subgraph Example 14

15 Can combine graphs, forming a union Let G1 = (V1, E1) and G2 = (V2, E2) The union, G1 G2 = (V1 V2, E1 E2) 15

16 Graph implementations All of the following representations can be used to create an instance of a directed graph in which loops are allowed: adjacency list adjacency matrix edge lists edge sets incidence matrices graphs 16

17 Representing Graphs Adjacency list: specifies vertices adjacent with each vertex in a simple graph can be used for directed graph as well - list terminal vertices adjacent from each vertex Vertex Adjacent vertices a c,d b e c a,d d a,c,e e d,b 17

18 Adjacency matrix Square grid of true/false values that represent the edges of a graph If the intersection of a row and column has a true value in it, there exists an edge between the vertices represented by the two indexes Since this is a directed graph, the value will be true only if there is an edge from the vertex indicated by the row index to the vertex indicated by the column index graphs 18

19 Adjacency matrix An adjacency matrix can be stored in a twodimensional array of bools or ints Each vertex is represented by one row and one column For a graph with four vertices, the following declaration could be used: boolean [][] amatrix = new boolean [4][4]; graphs 19

20 Adjacency matrix The graph above could be represented by the adjacency matrix on the right row [0] [1] [2] [3] column [0] [1] [2] [3] f t f f f f f t f f f f f t t t graphs 20

21 Representing Graphs: mathematical POV Adjacency matrix: n x n zero-one matrix with 1 representing adjacency, 0 representing non-adjacency Adjacency matrix of a graph is based on chosen ordering of vertices; for a graph with n vertices, there are n! different adjacency matrices Adjacency matrix of graph with few edges is a sparse matrix - many 0s, few 1s 21

22 Simple graph adjacency matrix With ordering a,b,c,d,e:

23 Using adjacency matrices for multigraphs and pseudographs With multiple edges, matrix is no longer zero-one: if more than one edge exists, list the number of edges A loop is represented with a 1 in position i,i Adjacency matrices for simple graphs, including multigraphs and pseudographs, are symmetric 23

24 Adjacency matrices and digraphs For directed graphs, the adjacency matrix has a 1 in its (i,j)th position if there is an edge from vi to vj Directed multigraphs can be represented by placing the number of edges in in position i,j that exist from vi to vj Adjacency matrices for digraphs are not necessarily symmetric 24

25 Edge lists Linked lists are used to represent vertices Each vertex is a linked list; nodes in each list contain numbers indicating the target vertices for that particular source vertex In other words, if list A contains a link to vertex B, there is an edge from A to B graphs 25

26 Edge lists For n vertices, there must be n lists; often the lists are stored as an array of list head references A vertex that is not a source would be represented in the array by a NULL pointer graphs 26

27 Edge lists [0] [1] [2] [3] 1 3 null 1 The graph above could be repesented by the array of edge lists on the right null null 2 3 graphs 27 null

28 Edge Sets Requires a previously programmed implementation of a set ADT Properties of a set: contains an unordered collection of entries each item is unique operations include insertion, deletion, and checking for the presence of a specific item To represent a graph with 4 vertices, can declare an array of 4 sets of ints graphs 28

29 Incidence Matrices In an adjacency matrix, both rows and columns represent vertices In an incidence matrix, rows represent vertices while columns represent edges A 1 in any matrix position means the edge in that column is incident with the vertex in that row Multiple edges are represented identical columns depicting the edges 29

30 Incidence Matrix Example e1 e2 e3 e4 e5 e6 e7 e8 e9 a b c d e

31 Choosing an implementation Adjacency matrix is easier to implement & use than any of the edge-based solutions Frequency of certain operations may dictate another solution graphs 31

32 Choosing an implementation Both adding and removing edges and checking for the presence of a particular edge are O(N) operations in the worst case for edge lists; may be as low as O(logN) for edge sets, depending on representation Edge lists are very efficient for operations that execute one time for each edge with a particular vertex graphs 32

33 Disadvantages of adjacency matrix Operations on all edges for a vertex require stepping through entire row (whether or not an entry is an edge) -- this is O(N) If each vertex has very few edges, an adjacency matrix is mostly wasted space graphs 33

34 Simple graph ADT implementation: labeled graph Operations: constructor add/removeedge size: returns number of vertices in graph isedge: returns true if edge exists between specified source & target clone get/setlabel neighbors: returns array of neighbors of a specified vertex graphs 34

35 Simple graph ADT implementation: labeled graph Data components: 2-dimensional int array representing edges array of vertex labels: each vertex includes data consisting of an informational label graphs 35

36 Labeled graph class definition public class Graph implements Cloneable { private boolean[ ][ ] edges; private Object[ ] labels; public Graph(int n) // n: # of vertices { edges = new boolean[n][n]; // All values initially false labels = new Object[n]; // All values initially null } graphs 36

37 Labeled graph class definition public void addedge(int source, int target) { edges[source][target] = true; } public void removeedge(int source, int target) { edges[source][target] = false; } public boolean isedge(int source, int target) { return edges[source][target]; } graphs 37

38 Labeled graph class definition public Object getlabel(int vertex) { return labels[vertex]; } public void setlabel(int vertex, Object newlabel) { labels[vertex] = newlabel; } public int size( ) { return labels.length; } graphs 38

39 Labeled graph class definition public int[ ] neighbors(int vertex) { int i, count=0; int[ ] answer; // First count how many edges have the vertex as their source for (i = 0; i < labels.length; i++) { if (edges[vertex][i]) count++; } // Allocate the array for the answer answer = new int[count]; graphs 39

40 Labeled graph class definition // Fill the array for the answer count = 0; for (i = 0; i < labels.length; i++) { if (edges[vertex][i]) answer[count++] = i; } return answer; } graphs 40

41 Labeled graph class definition public Object clone( ) { // Clone a Graph object. Graph answer; try { answer = (Graph) super.clone( ); } catch (CloneNotSupportedException e) { // This would indicate an internal error in the Java runtime system // because super.clone always works for an Object. throw new InternalError(e.toString( )); } answer.edges = (boolean [ ][ ]) edges.clone( ); answer.labels = (Object [ ]) labels.clone( ); return answer; } graphs 41

42 Graph traversals Traversal: visiting all nodes in a data structure Can t apply tree traversal methods to graphs, since nodes in a graph don t have the same child/parent relationships Graph traversal methods utilize subsidiary data structures (queues and stacks) to keep track of vertices to be visited graphs2 42

43 Graph traversals Purpose of traversal algorithm: starting at a given vertex, process the information at that vertex, then move along an edge to process a neighbor When traversal is complete, all vertices that can be reached from the start vertex (but not necessarily all vertices in the graph) have been visited graphs2 43

44 Depth-first search After processing the initial vertex, a depth-first search moves along an edge to one of the vertex s neighbors Once the second vertex is processed, the search moves along an edge to one of its neighbors The process continues to move forward as long as vertices can be reached in this manner graphs2 44

45 Depth-first search The search always proceeds forward until no further forward moves can be made Once forward motion is no longer possible at the current node, the search backs up to the previous vertex and visits any previously unvisited neighbors Eventually the search backs up to the original starting node, having visited all nodes that were reachable from this point graphs2 45

46 Depth-first printing routine public static void depthfirstprint(graph g, int start) { boolean[ ] marked = new boolean [g.size( )]; depthfirstrecurse(g, start, marked); } // The part of a stack is played here by the system stack; // the depthfirstrecurse method stacks up activation records // with each call graphs 46

47 Recursive method for depth-first printing public static void depthfirstrecurse(graph g, int v, boolean[ ] marked) { int[ ] connections = g.neighbors(v); int i, nextneighbor; marked[v] = true; System.out.println(g.getLabel(v)); // Traverse all the neighbors, looking for unmarked vertices: for (i = 0; i < connections.length; i++) { nextneighbor = connections[i]; if (!marked[nextneighbor]) depthfirstrecurse(g, nextneighbor, marked); } } graphs 47

48 Breadth-first search Uses queue to keep track of vertices which might still have unprocessed neighbors Initial vertex is processed, marked, and placed in queue Repeats the following until queue is empty: remove vertex from front of queue for each unmarked neighbor of the current vertex, mark the neighbor, then place the neighbor on the queue graphs2 48

Graphs. The ultimate data structure. graphs 1

Graphs. The ultimate data structure. graphs 1 Graphs The ultimate data structure graphs 1 Definition of graph Non-linear data structure consisting of nodes & links between them (like trees in this sense) Unlike trees, graph nodes may be completely