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

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 )

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

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

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

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

E.G.M. PetrakisGraphs relation weighted

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

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

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

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

E.G.M. PetrakisGraphs12 Representation of Directed Graphs directed graph adjacency matrix adjacency list

E.G.M. PetrakisGraphs13 Representation of Undirected Graphs undirected graph adjacency list adjacency matrix

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

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 };

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; }

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

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; }

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; }

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; }

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; }

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 };

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;

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 }

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; }

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; }

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; }

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

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

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

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) }

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

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 v7v

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

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); }

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

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

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); }

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); }

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

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|)

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

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

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

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

E.G.M. PetrakisGraphs46 Min. Cost Spanning Tree cost T = Prim’s algorithm: Complexity O(|V| 2 )

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 }

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; }

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

E.G.M. PetrakisGraphs starting point: v = 1 stepSWD(2)D(3)D(4)D(5) 1{1}-10i nfinite {1,2} {1,2,4} {1,2,4,3} {1,2,4,3,5}

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

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); }

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 )