1. E.G.M. PetrakisGraphs1  Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes  V = {A, B, C, D, E, F, G}  E = {AA, AB, AD, CD, DE, BF, EF, FG, EG } A B G C E F D

2. E.G.M. PetrakisGraphs2 Terminology  Two vertices are adjacent if they are connected with an edge  Adjacent or neighbor vertices  Subgraph of G=(V,E): a graph G’=(V’,E’) where V’, E’ are subsets of V, E  |V|,|E|: number of nodes, edges of G  Complete graph: contains all possible edges  |E| in Θ(|V| 2 )

3. E.G.M. PetrakisGraphs3 Undirected Graphs  The edges are not directed from one vertex to another G E H A B C F D

4. E.G.M. PetrakisGraphs4 Directed Graphs  The edges are directed from one vertex to another G E H A B C F D

5. E.G.M. PetrakisGraphs5 G E A BC FD A D BC

6. E.G.M. PetrakisGraphs6 More Definitions  Vertex degree: maximum number of incoming or outgoing edges  in-degree: number of incoming edges  out-degree: number outgoing edges  Relation R on A: R = { | x, y ∊ N}  x < y  x mod y = odd  Labeled graph: labels on vertices or edges  Weighted graph: weights on edges

7. E.G.M. PetrakisGraphs7 8 310 6 17 5 relation 8 310 6 17 5 1 7 13 1 5 weighted

8. E.G.M. PetrakisGraphs8 Paths  There exist edges connecting two nodes  Length of path: number of edges  Weighted graphs: sum of weights on path  Cycle: path (of length 3 or more) connecting a vertex with itself  Cyclic graph: contains cycle  Acyclic graph: does not contain cycle  DAG: Directed Acyclic Graph

9. E.G.M. PetrakisGraphs9 Connected Graphs  An undirected graph is connected if there is a path between any two vertices  Connected components: maximally connected subgraphs 0 1 4 3 26 5 7

10. E.G.M. PetrakisGraphs10 Operations on Graphs  join (a,b)  join (a,b,x)  remv[wt] (a,b,x)  adjacent (a,b) a b a b a b a b x a b c adjacent (a,b) = true adjacent (a,c) = false a b a b

11. E.G.M. PetrakisGraphs11 Build a Graph read(n);// number of nodes read and create n nodes label them from 1.. n while not eof(..) { read(node 1, node 2, w 12 ); joinwt(node 1, node 2, w 12 ); } any graph algorithm

12. E.G.M. PetrakisGraphs12 Representation of Directed Graphs 02 4 31 directed graph 11 1 1 1 1 34210 0 1 2 3 4 adjacency matrix 14 3 4 2 1 4 3 2 0 1 adjacency list

13. E.G.M. PetrakisGraphs13 Representation of Undirected Graphs 02 4 31 undirected graph adjacency list 14 0 3 1 0 4 3 2 0 1 3 4 2 1 4 2 adjacency matrix 34210 0 1 2 3 4 1 1 1 1 1 11 1 1 1 1 1

14. E.G.M. PetrakisGraphs14 Matrix Implementation  Simple but difficult to process edges, unused space in matrix  mark: 1D array marking vertices  mark[i] = 1 if vertex i has been visited  typedef int * Edge;  matrix: the actual Graph implemented as an 1D array of size n 2  edge (i, j) is found at matrix[i * n + j]  if edge exists matrix[i * n + j] = wt  otherwise matrix[i * n + j] = NOEDGE

15. E.G.M. PetrakisGraphs15 Graph class: Adjacency Matrix template class Graph { private: Edge* matrix;// the edge matrix int numVertex, numEdge;// number of vertices, edges bool* Mark;// the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e ( )// number of vertices, edges Edge first(int);// get the first edge for a vertex bool isEdge(Edge);// TRUE if this is an edge Edge next(Edge);// get next edge for a vertex int v1(Edge), v2(Edge)// vertex edge comes from, goes to int weight(int, int);// return weight of edge int weight(Edge);// return weight of edge };

16. E.G.M. PetrakisGraphs16 Constructor, Destructor template Graph ::Graph( ) { mark = NULL; matrix = NULL; } template Graph ::~Graph( ) { if (mark != NULL) delete [ ] mark; if (matrix != NULL) delete [ ] matrix; }

17. E.G.M. PetrakisGraphs17 Member Functions template int Graph ::n( ) { return numVertex; } template int Graph ::e( ) { return numEdge; }

18. E.G.M. PetrakisGraphs18 Member Functions (cont.) template Edge Graph ::first(int v) {//first edge of node int stop = (v+1) * numVertex; // pos. at end of v’s row for ( int pos = v * numVertex; pos < stop; pos++) //scans entire row if ( matrix[pos] != NOEDGE) return &matrix[pos]; return NULL; }

19. E.G.M. PetrakisGraphs19 Member Functions (cont.) template bool Graph ::isEdge(Edge w) { return w != NULL; } template Edge Graph ::next(Edge w) { // next edge of (w,0) int stop = (v1(w) + 1) * numVertex; // pos at end of row for (int pos = (w – matrix) + 1; pos < stop; pos++) if (matrix[pos] != NOEDGE)return &matrix[pos]; return NULL; }

20. E.G.M. PetrakisGraphs20 Member Functions (cont.) template int Graph ::v1(Edge w) // 1 st vertex of edge { return ( w – matrix ) / numVertex; } template int Graph ::v2(Edge w) // 2 nd vertex edge { return ( w – matrix ) % numVertex; }

21. E.G.M. PetrakisGraphs21 Member Functions (cont.) template int Graph ::weight( int i, int j) {// return weight of edge if ( matrix[ i * numVertex + j ] == NOEDGE ) return INFINITY; else return matrix[ i * numVertex + j ]; } template int Graph ::weight(Edge w) {// return weight of edge if ( * w == NOEDGE ) return INFINITY; else return * w; }

22. E.G.M. PetrakisGraphs22 Graph Class: Adjacency List template class Graph { private: Edge * list;// the vertex list int numVertex;// number of vertices int numEdge;// number of edges bool * Mark;// the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e( );// number of vertices, edges Edge first(int);// get the first edge of vertex bool isEdge(Edge);// TRUE if this is an edge Edge next(Edge);// get next edge for a vertex int v1(Edge), v2(Edge);// return vertex edge comes from, goes to int v2(Edge);// return vertex edge goes to int weight(int, int),// return weight of edge int weight(weight);// return weight of edge };

23. E.G.M. PetrakisGraphs23 A Singly-Linked List Node  class EdgeLink { public: int weight;// edge weight int v1;// 1 st vertex of edge int v2; // 2 nd vertex of edge EdgeLink * next;// pointer to next edge in list EdgeLink(int vt1, int vt2, int w, EdgeLink * nxt = NULL) // constructor { v1 = vt; v2 = vt2; weight = w; next = nxt; } };  Graph g;

24. E.G.M. PetrakisGraphs24 Member Functions template Graph ::Graph( ) {// constructor Mark = NULL;list = NULL; } template Graph ::~Graph( ) {// destructor: return allocated space if (Mark != NULL) delete [ ] Mark; if (list != NULL) {// remove all of the edges for (int v = 0; v < n( ); v++)// for each vertex return all edges while (list[v] != NULL) { list[v]= list[v]  next; delete temp; } delete [ ] list;// remove the vertex list headers }

25. E.G.M. PetrakisGraphs25 Member Functions (cont.) template int Graph ::n( ) { return numVertex; } // number of vertices template int Graph ::e( ) { return numEdge; } // number of edges template Edge Graph ::first(int v) // get the first edge {return list[v]; } template bool Graph ::isEdge(Edge w) // TRUE if it is an edge { return w != NULL; }

26. E.G.M. PetrakisGraphs26 Member Functions (cont.) template Edge Graph ::next(Edge w) {// get next edge for a vertex if (w == NULL) return NULL; else return w  next; } template int Graph ::v1(Edge w)// return vertex edge comes from { return w  v1; } template int Graph ::v2(Edge w)// return vertex edge goes to { return w  v2; }

27. E.G.M. PetrakisGraphs27 Member Functions (cont.) template int Graph ::weight( int i, int j) {// return weight of edge for (Edge curr = list[i]; curr != NULL; curr = curr->next) if (curr  v2 == j ) return curr-> weight; return INFINITY; } template int Graph ::weight(Edge w) {// return weight of edge if ( w == NULL ) return INFINITY; else return w -> weight; }

28. E.G.M. PetrakisGraphs28 A Better Implementation ndptr: pointer to adjacent node nextarc: pointer to next edge arcptrinfonextnode info: data arcptr: pointer to an adjacent node nextnode: pointer to a graph node ndptrnextarc E A B C D

29. E.G.M. PetrakisGraphs29 AΒ nilnil CDE nilnil nilnil nilnil nilnil nilnil graph

30. E.G.M. PetrakisGraphs30 Graph Traversal  Trees  preorder  inorder  postorder  Graphs  Depth First Search (DFS)  Breadth First Search (BFS)

31. E.G.M. PetrakisGraphs31 Depth First Search (DFS)  Starting from vertex v, initially all vertices are “ unvisited ”  void DFS(v) { Mark(v) = true; for each vertex w adjacent to v if (!Mark(w)) DFS(w) }

32. E.G.M. PetrakisGraphs32 Complexity of DFS  O(|V| + |E|): adjacency list representation  O(|V| 2 ) in dense graphs  O(|V| 2 ): matrix representation

33. E.G.M. PetrakisGraphs33 DFS : V 1 V 2 V 4 V 8 V 5 V 6 V 3 V 7 v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8 v3v3 v2v2 v1v1 v6v6 v5v5 v4v4 v8v8 v7v7 2 1 1 2 2 3 3 4 3 4 6 8 8 8 8 5 5 7 7 6

34. E.G.M. PetrakisGraphs34 Breadth-First Search (BFS) ΒFS : V 1 V 2 V 3 V 4 V 5 V 6 V 7 V 8 v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8

35. E.G.M. PetrakisGraphs35 BFS (cont.)  Starting from vertex v, all nodes “ unvisited ”, visit adjacent nodes (use a queue) void DFS(v) { visited(v) = true; enqueue(v, Q); while ( Q ≠ 0 ) { x = dequeue(Q); for each y adjacent x do if ! Mark(y) { Mark(y) = TRUE; enqueue(y,Q); }

36. E.G.M. PetrakisGraphs36 v1v1 front rear v3v3 v2v2 front rear output(v 1 ) v3v3 front rear v5v5 v4v4 output(v 2 ) output(v 3 ) v4v4 front rear v7v7 v5v5 v6v6 v5v5 front rear v8v8 v6v6 v7v7 output(v 4 ) v6v6 front v7v7 v8v8 output(v 5 ) v6v6 front v8v8 output(v 6 ) output(v 7 ) v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8

37. E.G.M. PetrakisGraphs37 Complexity of BFS  O(|V|+|E|) : adjacency list representation  d 1 + d 2 +...+ d n = |E|  d i = degree (v i )  O(|V| 2 ) : adjacency matrix representation

38. E.G.M. PetrakisGraphs38 DFS Algorithm template void DFS (Graph & G, int v) { action(G,v); G.Mark[v] = VISITED; for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v 2 (w)] = = UNVISITED) DFS ( G, G.v 2 (w)); action(G,v); }

39. E.G.M. PetrakisGraphs39 BFS Algorithm template void BFS (Graph & G, int start) { Queue Q(G.n( )); Q.enqueue(start); G.Mark[start] = VISITED; While ( !Q.isempty( )){ int v = Q.dequeue( ); action(G,v); for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v 2 (w)] = = UNVISITED) { G.Mark[G.v 2 (w)] = VISITED; Q.enqueue(G.v 2 (w)); } action(G,v); }

40. E.G.M. PetrakisGraphs40 Connected - Unconnected A BC D E connected components E F G A B C D connected graph: undirected graph, there is a path connecting any two nodes unconnected graph: not always a path

41. E.G.M. PetrakisGraphs41 Connected Components  If there exist unconnected nodes in a DFS or BFS traversal of G then G is unconnected  Find all connected components: void COMP(G, n) { for i = 1 to n if Mark(i) == UNVISITED then DFS(i) [or BFS(i)]; }  Complexity: O(|V| + |E|)

42. E.G.M. PetrakisGraphs42 Spanning Trees (G,E) Tree formed from edges and nodes of G Spanning Tree

43. E.G.M. PetrakisGraphs43 Spanning Forest  Set of disjoint spanning trees T i of G=(V,E)  T i = ( V i, E i ) 1≤ i ≤ k, V i,E i :subsets of V, E  DFS produces depth first spanning trees or forest  BFS breadth first spanning trees or forest  Undirected graphs provide more traversals  produce less but short spanning trees  Directed graphs provide less traversals  produce more and higher spanning trees

44. E.G.M. PetrakisGraphs44 DFS DFS spanning tree D BC E A DFS C B DE A C BF E A G D D C EGF B A DFS spanning forest

45. E.G.M. PetrakisGraphs45 BFS BFS spanning tree ΒFS E BC F A D GE BC F A D G BFS spanning forest C BF E A H D C H DE F B A ΒFS

46. E.G.M. PetrakisGraphs46 Min. Cost Spanning Tree cost T = 1 + 5 + 2 + 4 + 3 3 1 1 3 6 1 4 1 3 6 1 4 42 1 23 6 1 4 5 42 1 5 23 6 1 4 5 3 42 1 5 23 6 1 4 6 5 6 6 3 42 5 5 1 Prim’s algorithm: Complexity O(|V| 2 )

47. E.G.M. PetrakisGraphs47 Prim’s Algorithm template void Prim(Graph & G, int s){/ /prim’s MST algorithm int D[G.n( )];// distance vertex int V[G.n( )];// who’s closest for (int i=0; i<G.n( ); i++); D[i] = INFINITY; // initialize D[s] = 0; for ( i=0; i<G.n( ); i++){// process the vertices int v = minVertex(G, D); G.Mark[v] = VISITED; if ( v != s ) AddEdgetoMST(V[v], v);// add this edge to MST if (D[v] = = INFINITY ) return;// unreachable vertices for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (D[G.v2(w)] > G.weight(w)) { D[G.v2(w)] = G.weight(w);// update distance and V[G.v2(w)] = v;// who it came from }

48. E.G.M. PetrakisGraphs48 Prim’s Algorithm (cont.) template ){ // find min cost vertex void minVertex(Graph & G, int* D int v; for (int i = 0; i < G.n( ); i++)// initialize if (G.Mark[i] = = UNVISITED){ v = i; break; } for ( i=0; i<G.n( ); i++)// find smallest value if ((G.Mark[i] = = UNVISITED) && ( D[i] < D[v] )) v = i; return v; }

49. E.G.M. PetrakisGraphs49 Dijkstra’s Algorithm  Find the shortest path from a given node to every other node in a graph G  no better algorithm for single ending node  Notation:  G = (V,E) : input graph  C[i,j] : distance between nodes i, j  V : starting node  S : set of nodes for which the shortest path from v has been computed  D(W) : length of shortest path from v to w passing through nodes in S

50. E.G.M. PetrakisGraphs50 20 1 2 3 5 4 100 10 60 50 10 30 starting point: v = 1 stepSWD(2)D(3)D(4)D(5) 1{1}-10i nfinite 30100 2{1,2}2106030100 3{1,2,4}410503090 4{1,2,4,3}310503060 5{1,2,4,3,5}510503060

51. E.G.M. PetrakisGraphs51 Dijkstra’s Algorithm (cont.) Dijkstra(G: graph, int v) { S = {1}; for i = 2 to n D[i] = C[i,j]; while (S != V) { choose w from V-S: D[w] = minimum S = S + {w}; for each v in V–S: D[v] = min{D[v], D[w]+[w,v]}*; } * If D[w]+C[w,v] < D[v] then P[v] = w: keep path in array

52. E.G.M. PetrakisGraphs52 Compute Shortest Path template void Dijkstra(Graph & G, int s) { int D[G.n( )]; for (int i=0; i < G.n( ); i++) // initialize D[i] = INFINITY; D[s] = 0; for (i = 0; i < G.n( ); i++) { // process the vertices int v = minVertex(G, D); if (D[v] == INFINITY) return; // remaining vertices unreachable G.setMark(v, VISITED); for (Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (D[G.v2(w)] > (D[v] + G.weight(w))) D[G.v2(w)] = D[v] + G.weight(w); }

53. E.G.M. PetrakisGraphs53 Find Min. Cost Vertex template int minVertex(Graph & G, int* D) { int v; for (int i = 0; i < G.n( ); i++) if (G.getMark(i) == UNVISITED) { v = i; break; } for (i++; i < G.n( ); i++) // find smallest D value if ((G.getMark(i) == UNVISITED) && (D[i] < D[v])) v = i; return v; }  minVertex: scans through the list of vertices for the min. value  O(|V|) time  Complexity: O(|V| 2 + |E|) = O(|V| 2 ) since O(|E|) is O(|V| 2 )