Graph Implementation

• graphs:
  • undirected
  • directed
  • directed acyclic
• graph implementations:
  • adjacency matrix
  • edge lists
  • graph ADT

Graphs

• very general data structure: generalizes
  • all kinds of trees
  • lists
• nodes and links between the nodes
• a node is called a vertex
• a link is called an edge
• example: draw a graph with 4 vertices and 5 edges

Undirected Graphs

• each edge connect two vertices (or a vertex to itself)
• vertices are drawn as circles
• edges are drawn as lines
• placement is unimportant -- it is only important which vertices are connected to which edges

Undirected Graphs -- example

• 3-coin game:
  • start with head, tail, head
  • can flip the middle coin any time
  • can flip an end coin only when the other two coins are equal
  • stop when you reach tail, head, tail
• represent each possible state of the game as a vertex
• represent possible transitions as edges (fig 14.1, p. 666)
• in this game, all transitions are bidirectional
• can solve this game by finding a path in the graph

Directed Graphs

• edges in a directed graph are directed (drawn as arrows): they go from a source to a target vertex
• a path is a sequence of vertices v₁ ... v_n such that for each 0 < i < n, there is a directed edge from v_i to v_i+1
• for both directed and undirected graphs:
  • a loop is an edge whose source and target are the same vertex
  • two or more edges with the same source and the same target are multiple edges
  • a simple graph is defined as a graph that has no loops and no multiple edges

Directed Graphs -- example

• use a directed graph to represent the flights of an airline
• airports are the vertices
• routes are the edges
• the airline might fly from Hilo to Kapalua, but not from Kapalua to Hilo -- the airplane continues on to Honolulu
• one way to figure out whether you can fly from Kapalua to Hilo is to find a path in the graph from the vertex representing Kapalua to the vertex representing Hilo

Directed Acyclic Graphs

• a directed graphs without cycles (all paths have finite length) is a Directed Acyclic Graphs, or DAG
• if duplication of vertices is allowed, a DAG can always be mapped to a tree
• traversing a DAG is no harder than traversing a tree

In-class exercise: graph representation

• what data structure(s) would you use to represent a graph?
• 10 minutes
• work alone or in groups of up to 4

Adjacency Matrix

• directed graph with v vertices, and without multiple edges
• square grid of bits, v * v
• bit at row i, column j is true or 1 if and only if there is an edge from v_i to v_j,

Multidimensional arrays in Java

• a two-dimensional array in Java is declared and used as follows:

  // 12 rows, 8 columns
  double [] [] budget
     = new double [12] [8];
  budget [1] [7] = 17.9;
  

• a two-dimensional square array of bits might be:

  boolean [] [] adjacent
     = new boolean [4] [4];
  if (adjacent [3] [1]) ...
  

Edge Lists

• for each vertex, store a list of the other vertices to which we have an edge
• store all the lists in a single array
• allows loops, multiple edges

Edge Sets and Edge Bags

• given an implementation of Set (or Bag)
• for each vertex, store a Set (or Bag) of the other vertices to which we have an edge
• store all the sets (bags) in a single array
• allows loops
• if using bags, allows multiple edges

Comparison of representations

• how often will we be:
  1. adding or removing edges
  2. checking for the presence of a particular edge
  3. operating on all the edges with a give source vertex

  	adjacency	edge lists
  space	O(v2)	O( max(v,e))
  add/rem	O(1)	O(1)/O(n)
  checking	O(1)	O( maxv(e))
  all edges of i	O(v)	O( maxv(e))

• edge lists/bags can represent multiple edges

Graph ADT

• use adjacency matrix
• vertices can hold arbitrary objects: the labels, making this a labeled graph
• int [] neighbors (int vertex) method computes the neighbors of a vertex
• number of vertices is fixed; edges may change

public class Graph {
  private boolean [] [] edges;
  private Object [] labels;
  public Graph (int n) {
    edges = new boolean [n] [n];
    labels = new Object [n]; // null
  }