Download ch20

Chapter 20: Graphs
Java Programming:
Program Design Including Data Structures
Chapter Objectives
 Learn about graphs
 Become familiar with the basic terminology of graph
theory
 Discover how to represent graphs in computer
memory
 Explore graphs as ADTs
Java Programming: Program Design Including Data Structures
2
Chapter Objectives (continued)
 Examine and implement various graph traversal
algorithms
 Learn how to implement the shortest path algorithm
 Examine and implement the minimal spanning tree
algorithm
Java Programming: Program Design Including Data Structures
3
Introduction
Figure 20-1 Königsberg bridge problem
Java Programming: Program Design Including Data Structures
4
Introduction (continued)
 The Königsberg bridge problem
 Starting at one land area, is it possible to walk across
all the bridges exactly once and return to the starting
land area?
 Can be represented as a graph
 Answer the question in the negative
Java Programming: Program Design Including Data Structures
5
Introduction (continued)
Figure 20-2 Graph representation of Königsberg bridge problem
Java Programming: Program Design Including Data Structures
6
Graph Definitions and Notations
 If a is an element of X, then a  X
 Y is a subset of X (Y  X)
 If every element of Y is also an element of X
 Intersection of A and B (A  B)
 Set of all the elements that are in A and B
 Union of A and B (A  B)
 Set of all the elements that are in A or in B
 A X B = {(a, b) | a  A, b  B}
Java Programming: Program Design Including Data Structures
7
Graph Definitions and Notations
(continued)
 Graph G = (V,E)
 V is a finite nonempty set of vertices
 E  V X V (called the set of edges)
 G is called a directed graph or digraph
 If elements of E(G) are ordered pairs
 Otherwise G is called an undirected graph
 If (u,v) is a digraph edge
 Vertex u is called the origin and vertex v the
destination of the edge
Java Programming: Program Design Including Data Structures
8
Graph Definitions and Notations
(continued)
Figure 20-3 Various undirected graphs
Java Programming: Program Design Including Data Structures
9
Graph Definitions and Notations
(continued)
Figure 20-4 Various directed graphs
Java Programming: Program Design Including Data Structures
10
Graph Definitions and Notations
(continued)
 Adjacent vertices have an edge from one to the other
 Consequently, the edge is incident on both vertices
 Loop is an edge incident on a single vertex
 Parallel edges are incident on the same pair of
vertices
 A simple graph has no loops and parallel edges
 Vertices are connected if they have a path
Java Programming: Program Design Including Data Structures
11
Graph Definitions and Notations
(continued)
 A connected graph has a path from any vertex to any
other vertex
 Component of G
 Maximal subset of connected vertices
 G is strongly connected if any two vertices are
connected
 If there is an edge from u to v
 u is adjacent to v
 v is adjacent from u
Java Programming: Program Design Including Data Structures
12
Graph Representation
 Adjacency matrix
 Adjacency list
Java Programming: Program Design Including Data Structures
13
Adjacency Matrix
 Two-dimensional n x n matrix
 (i, j)th entry is 1 if there is an edge from vi to vj
 Adjacency matrix of an undirected graph is
symmetric
Java Programming: Program Design Including Data Structures
14
Adjacency List
 Corresponding to each vertex v
 There is a linked list with all vertex u such that (u, v )
 E(G)
 Because there are n nodes
 You can use an array A of size n
 A[ i ] contains the linked list of vertices to which vi is
adjacent
Java Programming: Program Design Including Data Structures
15
Adjacency List (continued)
Figure 20-5 Adjacency list of graph G2 of Figure 20-4
Java Programming: Program Design Including Data Structures
16
Operations on Graphs
 Operations commonly performed on graphs





Create the graph
Clear the graph
Determine whether the graph is empty
Traverse the graph
Print the graph
Java Programming: Program Design Including Data Structures
17
Implementing Graph Operations
 Method isEmpty
public boolean isEmpty()
{
return (gSize == 0);
}
Java Programming: Program Design Including Data Structures
18
Implementing Graph Operations
(continued)
 Method createGraph
public void createGraph()
{
Scanner console = new Scanner(System.in);
String fileName;
if (gSize != 0)
clearGraph();
Scanner infile = null;
try
{
System.out.print(“Enter input file name: “);
fileName = console.nextLine();
System.out.println();
infile = new Scanner(new FileReader(fileName));
}
Java Programming: Program Design Including Data Structures
19
Implementing Graph Operations
(continued)
catch (FileNotFoundException fnfe)
{
System.out.println(fnfe.toString());
System.exit(0);
}
gSize = infile.nextInt(); //get the number of vertices
for (int index = 0; index < gSize; index++)
{
int vertex = infile.nextInt();
int adjacentVertex = infile.nextInt();
while (adjacentVertex != -999)
{
graph[vertex].insertLast(adjacentVertex);
adjacentVertex = infile.nextInt();
} //end while
} // end for
}//end createGraph
Java Programming: Program Design Including Data Structures
20
Implementing Graph Operations
(continued)
 Method clearGraph
public void clearGraph()
{
int index;
for (index = 0; index < gSize; index++)
graph[index] = null;
gSize = 0;
}
Java Programming: Program Design Including Data Structures
21
Implementing Graph Operations
(continued)
 Method printGraph
public void printGraph()
{
for (int index = 0; index < gSize; index++)
{
System.out.print(index + “ ”);
graph[index].print();
System.out.println();
}
System.out.println();
}
Java Programming: Program Design Including Data Structures
22
Implementing Graph Operations
(continued)
 Constructor
public Graph()
{
maxSize = 100;
gSize = 0;
graph = new UnorderedLinkedList[maxSize];
for (int i = 0; i < maxSize; i++)
graph[i] = new UnorderedLinkedList<Integer>();
}
Java Programming: Program Design Including Data Structures
23
Implementing Graph Operations
(continued)
 Constructor
public Graph(int size)
{
maxSize = size;
gSize = 0;
graph = new UnorderedLinkedList[maxSize];
for (int i = 0; i < maxSize; i++)
graph[i] = new UnorderedLinkedList<Integer>();
}
Java Programming: Program Design Including Data Structures
24
Graph Traversals
 Traversals
 Depth first traversal
 Similar to the preorder traversal of a binary tree
 Breadth first traversal
 Similar to traversing a binary tree level by level
Java Programming: Program Design Including Data Structures
25
Depth First Traversal
 Method dft
private void dft(int v, boolean[] visited)
{
visited[v] = true;
System.out.print(“ ” + v + “ ”); //visit the vertex
UnorderedLinkedList<Integer>.
LinkedListIterator<Integer> graphIt
= graph[v].iterator();
while (graphIt.hasNext())
{
int w = graphIt.next();
if (!visited[w])
dft(w, visited);
} //end while
} //end dft
Java Programming: Program Design Including Data Structures
26
Depth First Traversal (continued)
 Method depthFirstTraversal
public void depthFirstTraversal()
{
boolean[] visited; //array to keep track of the
//visited vertices
visited = new boolean[gSize];
for (int index = 0; index < gSize; index++)
visited[index] = false;
for (int index = 0; index < gSize; index++) //for each
//vertex that
if (!visited[index])
//has not been visited
dft(index, visited);
//do a depth first
//traversal
} //end depthFirstTraversal
Java Programming: Program Design Including Data Structures
27
Depth First Traversal (continued)
 Method dftAtVertex
public void dftAtVertex(int vertex)
{
boolean[] visited;
visited = new boolean[gSize];
for (int index = 0; index < gSize; index++)
visited[index] = false;
dft(vertex,visited);
} //end dftAtVertex
Java Programming: Program Design Including Data Structures
28
Breadth First Traversal
 Method breadthFirstTraversal
public void breadthFirstTraversal()
{
LinkedQueueClass<Integer> queue = new LinkedQueueClass<Integer>();
boolean[] visited;
visited = new boolean[gSize];
for (int ind = 0; ind < gSize; ind++)
visited[ind] = false;
//initialize the array visited to false
for (int index = 0; index < gSize; index++)
if (!visited[index])
{
queue.addQueue(index);
visited[index] = true;
System.out.print(“ “ + index + “ “);
while (!queue.isEmptyQueue())
{
Java Programming: Program Design Including Data Structures
29
Breadth First Traversal (continued)
int u = queue.front();
queue.deleteQueue();
UnorderedLinkedList<Integer>.
LinkedListIterator<Integer> graphIt
= graph[u].iterator();
while (graphIt.hasNext())
{
int w1 = graphIt.next();
if (!visited[w1])
{
queue.addQueue(w1);
visited[w1] = true;
System.out.print(“ “ + w1 + “ “);
}
}
} //end while
} //end if
} //end breadthFirstTraversal
Java Programming: Program Design Including Data Structures
30
Shortest Path Algorithm
 Weight of the edge
 Nonnegative real number assigned to an edge
 Weighted graphs
 Graphs containing weighted edges
 Weight of the path
 Sum of the weights of all edges on path
 Shortest path
 Path with the smallest weight
Java Programming: Program Design Including Data Structures
31
Shortest Path Algorithm
(continued)
 Shortest path algorithm
 Also called a greedy algorithm
 Developed by Dijkstra
 Let W be a two-dimensional n x n matrix, such that
Java Programming: Program Design Including Data Structures
32
Shortest Path
 General algorithm:
 Initialize the array smallestWeight so that
smallestWeight[u] = weights[vertex, u]
 Set smallestWeight[vertex] = 0
 Find vertex v that is closest to vertex for which
shortest path has not been determined
 Mark v as the (next) vertex for which smallest weight
is found
 Update weight for each vertex w in G
Java Programming: Program Design Including Data Structures
33
Shortest Path (continued)
Figure 20-8 Weighted graph G
Java Programming: Program Design Including Data Structures
34
Shortest Path (continued)
Figure 20-9 Graph after Step 1 and 2 execute
Java Programming: Program Design Including Data Structures
35
Shortest Path (continued)
Figure 20-10 Graph after the first iteration of Steps 3, 4 and 5
Java Programming: Program Design Including Data Structures
36
Minimal Spanning Tree
 Weight of tree T, denoted by W(T)
 Sum of all weights of all edges in T
 Spanning tree
 Subgraph of G such that all vertices of G are in T
 Minimal spanning tree
 Spanning tree with the minimum weight
 Two well-known algorithms
 Prim’s algorithm
 Kruskal’s algorithm
Java Programming: Program Design Including Data Structures
37
Minimal Spanning Tree (continued)
 Method minimalSpanning
public void minimalSpanning(int sVertex)
{
source = sVertex;
boolean[] mstv = new boolean[maxSize];
for (int j = 0; j < gSize; j++)
{
mstv[j] = false;
edges[j] = source;
edgeWeights[j] = weights[source][j];
}
mstv[source] = true;
edgeWeights[source] = 0;
Java Programming: Program Design Including Data Structures
38
Minimal Spanning Tree (continued)
for (int i = 0; i < gSize - 1; i++)
{
double minWeight = Integer.MAX_VALUE;
int startVertex = 0;
int endVertex = 0;
for (int j = 0; j < gSize; j++)
if (mstv[j])
for (int k = 0; k < gSize; k++)
if (!mstv[k] && weights[j][k] < minWeight)
{
endVertex = k;
startVertex = j;
minWeight = weights[j][k];
}
mstv[endVertex] = true;
edges[endVertex] = startVertex;
edgeWeights[endVertex] = minWeight;
} //end for
} //end minimalSpanning
Java Programming: Program Design Including Data Structures
39
Some Well-Known Graph Theory
Problems
 Three Utilities Problem
 Three houses are to be connected to three services by
the means of underground pipelines
 Traveling Salesperson Problem
 Salesperson starts from home city and visit all cities
exactly once and return home with the smallest cost
 Four Color Problem
 Color all vertices in a planer graph using only four
colors
Java Programming: Program Design Including Data Structures
40
Chapter Summary
 Graph theory
 Vertices and edges
 Digraph
 Graph representation
 Adjacency matrix
 Adjacency list
 Graph traversals
 Depth first traversal
 Breadth first traversal
Java Programming: Program Design Including Data Structures
41
Chapter Summary (continued)
 Shortest path algorithm
 Path with the smallest weight
 Minimal spanning tree
 Spanning tree with the minimum weight
 Algorithms: Prim and Kruskal
 Well-known problems
 Three Utilities Problem
 Traveling Salesperson Problem
 Four Color Problem
Java Programming: Program Design Including Data Structures
42