GraphWhat is a Graph?A graph is a Non-Linear Data Structure which consists of set of nodes called vertices V and set of edges E which links vertices. The set of edges describes relationships among the vertices.Formal definition of GraphA graph G is defined as follows:G=(V,E)V(G): a finite, nonempty set of verticesE(G): a set of edges (pairs of vertices)

Directed vs. undirected GraphWhen the edges in a graph have no direction, the graph is called undirected

undirected Graph

When the edges in a graph have a direction, the graph is called directed (or digraph). If the graph is directed, the order of the vertices in each edge is important.

directed graph

Graph vs. TreeTrees are special cases of graphs.

Graph terminologyAdjacent nodes: Two nodes are adjacent if they are connected by an edge.5 is adjacent to 7 7 is adjacent from 5

Path: A sequence of vertices that connect two nodes in a graphComplete graph: A graph in which every vertex is directly connected to every other vertex.What is the number of edges in a complete directed graph with N vertices?N * (N-1)

What is the number of edges in a complete undirected graph with N vertices?N * (N-1) / 2

Weighted graph: A graph in which each edge carries a value.

Sequential Representation of Graphsadjacency matrixThe most frequently used graph representation scheme is the adjacency matrix also referred as incidence matrix. A graph containing n vertices can be represented by a matrix with n rows and n columns. The matrix is formed by storing 1 in its ithrow and jthcolumn of the matrix, if there exists an edge between ithand jthvertex of the graph, and a 0, if there is no edge between ith and jthvertex of the graph.

LINKED LIST REPRESENTATION OF GRAPHSA schematic diagram of a linked representation of G in memory. Specifically, the linked representation will contain two lists (or files), a node list NODE and an edge list EDGE, as follows.

Graph implementationArray-based implementationA 1D array is used to represent the vertices.A 2D array (adjacency matrix) is used to represent the edges. Linked-list implementationA 1D array is used to represent the vertices.A list is used for each vertex v which contains the vertices which are adjacent from v (adjacency list).Graph searchingMethods: Depth-First-Search (DFS) or Breadth-First-Search (BFS).Depth-First-Search (DFS)What is the idea behind DFS?Travel as far as you can down a path Back up as little as possible when you reach a "dead end" (i.e., next vertex has been "marked" or there is no next vertex).DFS can be implemented efficiently using a stack.Breadth-First-Searching (BFS)What is the idea behind BFS?Look at all possible paths at the same depth before you go at a deeper level.Back up as far as possible when you reach a "dead end" (i.e., next vertex has been "marked" or there is no next vertex).BFS can be implemented efficiently using a queue.

Graph Program Implementation Javaimport java.io.*;import java.util.*; public class algo { private static final Graph.Edge[] GRAPH = { new Graph.Edge("a", "b", 7), new Graph.Edge("a", "c", 9), new Graph.Edge("a", "f", 14), new Graph.Edge("b", "c", 10), new Graph.Edge("b", "d", 15), new Graph.Edge("c", "d", 11), new Graph.Edge("c", "f", 2), new Graph.Edge("d", "e", 6), new Graph.Edge("e", "f", 9), }; private static final String START = "a"; private static final String END = "e"; public static void main(String[] args) { Graph g = new Graph(GRAPH); g.algo(START); g.printPath(END); //g.printAllPaths(); }} class Graph { private final Map graph; // mapping of vertex names to Vertex objects, built from a set of Edges /** One edge of the graph (only used by Graph constructor) */ public static class Edge { public final String v1, v2; public final int dist; public Edge(String v1, String v2, int dist) { this.v1 = v1; this.v2 = v2; this.dist = dist; } } /** One vertex of the graph, complete with mappings to neighbouring vertices */ public static class Vertex implements Comparable { public final String name; public int dist = Integer.MAX_VALUE; // MAX_VALUE assumed to be infinity public Vertex previous = null; public final Map neighbours = new HashMap(); public Vertex(String name) { this.name = name;Output:

} else if (this.previous == null) { System.out.printf("%s(unreached)", this.name); } else { this.previous.printPath(); System.out.printf(" -> %s(%d)", this.name, this.dist); } } public int compareTo(Vertex other) { return Integer.compare(dist, other.dist); } } /** Builds a graph from a set of edges */ public Graph(Edge[] edges) { graph = new HashMap(edges.length); //one pass to find all vertices for (Edge e : edges) { if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2)); } //another pass to set neighbouring vertices for (Edge e : edges) { graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist); //graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph } } /** Runs algo using a specified source vertex */ public void algo(String startName) { if (!graph.containsKey(startName)) { System.err.printf("Graph doesn't contain start vertex \"%s\"\n", startName); return; } final Vertex source = graph.get(startName); NavigableSet q = new TreeSet(); // set-up vertices for (Vertex v : graph.values()) { v.previous = v == source ? source : null; v.dist = v == source ? 0 : Integer.MAX_VALUE; q.add(v); } algo(q); } /** Implementation of algo's using a binary heap. */

} private void printPath() { if (this == this.previous) { System.out.printf("%s", this.name); private void algo(final NavigableSet q) { Vertex u, v; while (!q.isEmpty()) { u = q.pollFirst(); // vertex with shortest distance (first iteration will return source) if (u.dist == Integer.MAX_VALUE) break; // we can ignore u (and any other remaining vertices) since they are unreachable //look at distances to each neighbour for (Map.Entry a : u.neighbours.entrySet()) { v = a.getKey(); //the neighbour in this iteration final int alternateDist = u.dist + a.getValue(); if (alternateDist < v.dist) { // shorter path to neighbour found q.remove(v); v.dist = alternateDist; v.previous = u; q.add(v); } } } } /** Prints a path from the source to the specified vertex */ public void printPath(String endName) { if (!graph.containsKey(endName)) { System.err.printf("Graph doesn't contain end vertex \"%s\"\n", endName); return; } graph.get(endName).printPath(); System.out.println(); } /** Prints the path from the source to every vertex (output order is not guaranteed) */ public void printAllPaths() { for (Vertex v : graph.values()) { v.printPath(); System.out.println(); } }}

7