Data Structures and Algorithms Graph Representations PLSD 210ii

Data Structures and Algorithms Graph Representations PLSD 210(ii)

Graphs - Data Structures • Vertices • Map to consecutive integers • Store vertices in an array • Edges • Adjacency Matrix • Booleans TRUE - edge exists FALSE - no edge • O(|V|2) space

Graphs - Data Structures • Edges • Adjacency Matrix • O(|V|2) space • Can be compacted • 1 bit/entry • If undirected, top half only

Graphs - Data Structures • Edges • Adjacency Lists • For each vertex • List of vertices “attached” to it • For each edge • 2 entries • One in the list for each end • O(|E|) space Better for sparse graphs Undirected representation

Graphs - Traversing • Choices • Depth-First / Breadth-first • Depth First • Use an array of flags to mark “visited” nodes

Graphs - Depth-First struct t_graph { Graph data int n_nodes; graph_node *nodes; structure int *visited; Adj. Matrix am; Adjacency Matrix ADT } static int search_index = 0; void search( graph g ) { Mark all int k; for(k=0; k<g->n_nodes; k++) g->visited[k] search_index = 0; for(k=0; k<g->n_nodes; k++) { if ( !g->visited[k] ) visit( g, k ); } } nodes “not visited” = 0; Visit all the nodes attached to node 0, then. .

Graphs - Depth-First void visit( graph g, int k ) { int j; Mark the order in which g->visited[k] = ++search_index; this node was visited for(j=0; j<g->n_nodes; j++) { if ( adjacent( g->am, k, j ) ) { if ( !g->visited[j] ) visit( g, j ); } Visit all the nodes adjacent to this one

Graphs - Depth-First void visit( graph g, int k ) { int j; Mark the order in which g->visited[k] = ++search_index; this node was visited for(j=0; j<g->n_nodes; j++) { if ( adjacent( g->am, k, j ) ) { if ( !g->visited[j] ) visit( g, j ); } Visit all the nodes adjacent to this one C hack. . . Should be g->visited[j] != 0 Search_index == 0 means not visited yet!

Graphs - Depth-First Adjacency List version of visit void visit( graph g, int k ) { Adj. List. Node al_node; g->visited[k] = ++search_index; al_node = List. Head( g->adj_list[k] ); while( n != NULL ) { j = ANode. Index( List. Item( al_node ) ); if ( !g->visited[j] ) visit( g, j ); al_node = List. Next( al_node ); } }

Graphs - Depth-First Adjacency List version of visit void visit( graph g, int k ) { Adj. List. Node al_node; g->visited[k] = ++search_index; al_node = List. Head( g->adj_list[k] ); while( n != NULL ) { Assumes a List ADT with methods j = ANode. Index( List. Item( al_node ) ); List. Head if ( !g->visited[j] ) visit( g, j ); al_node = List. Next( al_node ); ANode. Index } List. Item } List. Next

Graph - Breadth-first Traversal • Adjacency List • Time complexity • Visited set for each node • Each edge visited twice • Once in each adjacency list • O(|V| + |E|) çO(|V|2) for dense |E| ~ |V|2 graphs • but O(|V|) for sparse |E| ~ |V| graphs • Adjacency Lists perform better for sparse graphs

Graph - Breadth-first Traversal • Breadth-first requires a FIFO queue static queue q; void search( graph g ) { q = Cons. Queue( g->n_nodes ); for(k=0; k<g->n_nodes; k++) g->visited[k] = 0; search_index = 0; for(k=0; k<g->n_nodes; k++) { if ( !g->visited[k] ) visit( g, k ); } void visit( graph g, int k ) { al_node; int j; Add. Int. To. Queue( q, k ); while( !Empty( q ) ) { k = Queue. Head( q ); g->visited[k] = ++search_index; . . .

Graph - Breadth-first Traversal • Breadth-first requires a FIFO queue void visit( graph g, int k ) { al_node; int j; Add. Int. To. Queue( q, k ); Put this node while( !Empty( q ) ) { k = Queue. Head( q ); g->visited[k] = ++search_index; al_node = List. Head( g->adj_list[k]); while( al_node != NULL ) { j = ANode. Index(al_node); if ( !g->visited[j] ) { Add. Int. To. Queue( g, j ); g->visited[j] = -1; /* C hack, 0 = false! */ al_node = List. Next( al_node ); } } on the queue