1. UCS 406 – Data Structures & Algorithms
Graphs
UCS 406 – Data Structures & Algorithms

2. What is a graph?
A data structure that consists of a set of nodes (vertices) and a set of edges that relate the nodes to each other
The set of edges describes relationships among the vertices

3. Formal definition of graphs
A graph G is defined as follows:
G=(V,E)
V(G): a finite, nonempty set of vertices
E(G): a set of edges (pairs of vertices)

4. Directed vs. undirected graphs
When the edges in a graph have no direction, the graph is called undirected

5. Directed vs. undirected graphs (cont.)
When the edges in a graph have a direction, the graph is called directed (or digraph)
Warning: if the graph is directed, the order of the vertices in each edge is important !!
E(Graph2) = {(1,3) (3,1) (5,9) (9,11) (5,7)

6. Trees vs graphs
Trees are special cases of graphs!!

7. Graph terminology
Adjacent nodes: two nodes are adjacent if they are connected by an edge
Path: a sequence of vertices that connect two nodes in a graph
Complete graph: a graph in which every vertex is directly connected to every other vertex
5 is adjacent to 7
7 is adjacent from 5

8. Graph terminology
The outdegree [outdeg(u)] of a node in G is the number of edges beginning at u.
The indegree of u [indeg(u)] is the number of edges ending at u.
A node u is called a source if it has a positive outdegree but zero indegree.
A node u is called sink if it has a zero outdegree but a positive indegree.

9. Graph Terminology
End vertices of an edge U and V are the endpoints of a
Edge incident on a vertex a, d, b are incident on v
Adjacent vertices u and v are adjacent
Degree of a vertex : x has degree 5
Sum of degree of all vertices is double the no of edges of an undirected graph
Parallel edges: h and i are parallel edges
Self loop : j is a self loop

10. Graph terminology (cont.)
What is the number of edges in a complete directed graph with N vertices? 
N * (N-1)

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

12. Graph terminology (cont.)
Weighted graph: a graph in which each edge carries a value

13. Cycle cycle - circular sequence of alternating vertices and edges
Each edge is preceded and followed by its endpoints
Simple cycle : such that all its vertices and edges are distinct
v, b, x, g, y, f, w, c, u, a, v is a simple cycle
u, c, w, e, x, g, y, f, w, d, v, a, u is not a simple cycle

14. Graph implementation Array-based implementation
A 1D array is used to represent the vertices
A 2D array (adjacency matrix) is used to represent the edges

15. Array-based implementation

16. Graph implementation (cont.)
Linked-list implementation
A 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)

17. Linked-list implementation

18. Adjacency matrix vs. adjacency list representation
Good for dense graphs --|E|~O(|V|2)
Memory requirements: O(|V| + |E| ) = O(|V|2 )
Connectivity between two vertices can be tested quickly
Adjacency list
Good for sparse graphs -- |E|~O(|V|)
Memory requirements: O(|V| + |E|)=O(|V|)
Vertices adjacent to another vertex can be found quickly

19. Adjacency matrix and Path Matrix
Suppose G is a simple directed graph with m nodes and suppose the nodes of G have been ordered and are called v1, v2 …. Vm. Then the adjacency matrix A =(aij) of the graph G is the m x m matrix defined as follows:
aij = 1 if there is an edge (vi,vj)
= 0 otherwise
Such a matrix with entries of only 0 and 1 is called a bit matrix or boolean matrix.
Suppose G is a simple directed graph with m nodes v1, v2 …. Vm. The path matrix or reachability matrix of G is the m-square matrix P = (pij) defined as follows:
Pij = 1 if there is path from vi to vj
= 0 otherwise

20. Adjacency matrix

21. Adjacency List

22. Graph searching
Problem: find a path between two nodes of the graph (e.g., Austin and Washington)
Methods: Depth-First-Search (DFS) or Breadth-First-Search (BFS)

23. 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 on a graph with n vertices and m edges takes O(n + m ) time.
DFS can be implemented efficiently using a stack

24. DFS Algorithm Initialize all nodes to the ready state (STATUS=1)
Push the starting node A onto STACK and change the status to the waiting state (STATUS=2)
Repeat steps 4 and 5 until STACK is empty
Pop the top node N of STACK. Process N and change its status to the processed state (STATUS=3)
Push onto STACK al the neighbors of N that are still in the ready state (STATUS=1) and change their status to the waiting state (STATUS=2)
Exit

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

27. BFS algorithm Initialize all nodes to the ready state (STATUS=1)
Push the starting node A in QUEUE and change the status to the waiting state (STATUS=2)
Repeat steps 4 and 5 until QUEUE is empty
Remove the front node N of QUEUE. Process N and change its status to the processed state (STATUS=3)
Add to the rear of QUEUE all the neighbors of N that are still in the ready state (STATUS=1) and change their status to the waiting state (STATUS=2)
Exit

29. Operations on Graph Adding a node Deleting a node Adding an edge
Deleting an edge

30. Node Search

31. Adding Node

32. Deleting Node with Item

33. Delete Node

34. Find Edge

35. Insert Edge

36. Delete Edge

37. Heaps and Heap Sort

38. Special Types of Trees
Full binary tree 2 14 8 1 16 7 4 3 9 10 12
Def: Full binary tree = a binary tree in which each node is either a leaf or has degree exactly 2.
Def: Complete binary tree = In a complete binary tree every level, except possibly the last, is completely filled.
Complete binary tree 2 1 16 4 3 9 10

39. Definitions
Height of a node = the number of edges on the longest simple path from the node down to a leaf
Level of a node = the length of a path from the root to the node
Height of tree = height of root node
Height of root = 3 4 1 3
Height of (2)= 1 2 16 9 10
Level of (10)= 2 14 8

40. The Heap Data Structure
Def: A heap is a nearly complete binary tree with the following two properties:
Structural property: all levels are full, except possibly the last one, which is filled from left to right
Order (heap) property: for any node x
Parent(x) ≥ x
From the heap property, it follows that:
“The root is the maximum
element of the heap!” 8 7 4 5 2
A heap is a binary tree that is filled in order
Heap

41. Array Representation of Heaps
A heap can be stored as an array A.
Root of tree is A[1]
Left child of A[i] = A[2i]
Right child of A[i] = A[2i + 1]
Parent of A[i] = A[ i/2 ]
Heapsize[A] ≤ length[A]
The elements in the subarray A[(n/2+1) .. n] are leaves

42. Heap Types
Max-heaps (largest element at root), have the max-heap property:
for all nodes i, excluding the root:
A[PARENT(i)] ≥ A[i]
Min-heaps (smallest element at root), have the min-heap property:
A[PARENT(i)] ≤ A[i]

43. Adding/Deleting Nodes
New nodes are always inserted at the bottom level (left to right)
Nodes are removed from the bottom level (right to left)

44. Operations on Heaps Maintain/Restore the max-heap property
MAX-HEAPIFY
Create a max-heap from an unordered array
BUILD-MAX-HEAP
Sort an array in place
HEAPSORT
Priority queues

45. Maintaining the Heap Property
Suppose a node is smaller than a child
Left and Right subtrees of i are max-heaps
To eliminate the violation:
Exchange with larger child
Move down the tree
Continue until node is not smaller than children

46. Example MAX-HEAPIFY(A, 2, 10) A[2]  A[4]
A[2] violates the heap property
A[4] violates the heap property
A[2]  A[4]
Heap property restored
A[4]  A[9]

47. Maintaining the Heap Property
Alg: MAX-HEAPIFY(A, i, n)
l ← LEFT(i)
r ← RIGHT(i)
if l ≤ n and A[l] > A[i]
then largest ←l
else largest ←i
if r ≤ n and A[r] > A[largest]
then largest ←r
if largest  i
then exchange A[i] ↔ A[largest]
MAX-HEAPIFY(A, largest, n)
Assumptions:
Left and Right subtrees of i are max-heaps
A[i] may be smaller than its children

48. Building a Heap
Convert an array A[1 … n] into a max-heap (n = length[A])
The elements in the subarray A[(n/2+1) .. n] are leaves
Apply MAX-HEAPIFY on elements between 1 and n/2
Alg: BUILD-MAX-HEAP(A)
n = length[A]
for i ← n/2 downto 1
do MAX-HEAPIFY(A, i, n) 2 14 8 1 16 7 4 3 9 10 5 6 A: 4 1 3 2 16 9 10 14 8 7

49. Example: A 4 1 3 2 16 9 10 14 8 7
i = 5
i = 4
i = 3 2 14 8 1 16 7 4 3 9 10 5 6 2 14 8 1 16 7 4 3 9 10 5 6 14 2 8 1 16 7 4 3 9 10 5 6
i = 2
i = 1 14 2 8 1 16 7 4 10 9 3 5 6 14 2 8 16 7 1 4 10 9 3 5 6 8 2 4 14 7 1 16 10 9 3 5 6

50. Heapsort Goal: Idea: Sort an array using heap representations
Build a max-heap from the array
Swap the root (the maximum element) with the last element in the array
“Discard” this last node by decreasing the heap size
Call MAX-HEAPIFY on the new root
Repeat this process until only one node remains

51. Example: A=[7, 4, 3, 1, 2] MAX-HEAPIFY(A, 1, 2) MAX-HEAPIFY(A, 1, 3)

52. Alg: HEAPSORT(A) BUILD-MAX-HEAP(A) for i ← length[A] downto 2
do exchange A[1] ↔ A[i]
MAX-HEAPIFY(A, 1, i - 1)
Running time: O(nlgn) --- Can be shown to be Θ(nlgn)
O(n)
O(lgn)
n-1 times

53. Minimum Spanning Tree

54. Spanning Forest
Spanning sub graph is Sub graph of G containing all vertices of G
Spanning tree is Spanning sub graph that is itself a tree
A Minimum Spanning Tree (MST) is a subgraph of an undirected graph such that the subgraph spans (includes) all nodes, is connected, is acyclic, and has minimum total edge weight
Spanning forest is a sub graph that consists of a spanning tree in each connected component of a graph.

55. Minimum Spanning Tree
Given a connected graph G = (V, E) with real-valued edge weights, an MST is a subset of the edges such that T is a spanning tree whose sum of edge weights is minimized.

56. Prim Algorithm Use a priority queue Maintain set of explored nodes S.
For each unexplored node v, maintain the attachment cost a[v] = cost of cheapest edge v to a node in S.
O(V2 ) with an array; O(E log V) with a binary heap

57. Prim Algorithm

60. Kruskal Algorithm
It finds a MST for a connected weighted graph. This means it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized. If the graph is not connected, then it finds a minimum spanning forest (a minimum spanning tree for each connected component). Kruskal's algorithm is an example of a greedy algorithm. Complexity: O(E log V)
Prim grows in connected manner while as Kruskal can develop into forests of not connected components

61. Kruskal Algorithm

64. Shortest Path Algorithms

65. Single-source shortest-path problem
There are multiple paths from a source vertex to a destination vertex
Shortest path: the path whose total weight (i.e., sum of edge weights) is minimum
Examples: 
Austin->Houston->Atlanta->Washington: miles
Austin->Dallas->Denver->Atlanta->Washington: 2980 miles

66. Single-source shortest-path problem (cont.)
Common algorithms: Dijkstra's algorithm, Bellman-Ford algorithm
BFS can be used to solve the shortest graph problem when the graph is weightless or all the weights are the same
(mark vertices before Enqueue)

67. Dijkstra’s algorithm
Dijkstra's algorithm - is a solution to the single-source shortest path problem in graph theory. Works on both directed and undirected graphs. However, all edges must have nonnegative weights. Input: Weighted graph G={E,V} and source vertex v∈V, such that all edge weights are nonnegative Output: Lengths of shortest paths (or the shortest paths themselves) from a given source vertex v∈V to all other vertices

68. Approach
The algorithm computes for each vertex u the distance to u from the start vertex v, that is, the weight of a shortest path between v and u.
the algorithm keeps track of the set of vertices for which the distance has been computed, called the cloud C
Every vertex has a label D associated with it. For any vertex u, D[u] stores an approximation of the distance between v and u. The algorithm will update a D[u] value when it finds a shorter path from v to u.
When a vertex u is added to the cloud, its label D[u] is equal to the actual (final) distance between the starting vertex v and vertex u.

69. Dijkstra Algorithm

70. Example

71. Example

72. Example

73. Example

74. Example

75. Example

76. Example

77. Example

78. Example

79. Time Complexity Shortest path tree is union of all shortest path.
Complexity = |v| extract-min + |E| decrease key
For Array O(V2)
For Binary heap O(V+E) lgV
For Fibonacci Heap O(E+V lg V)
Dijkstra is equivalent to a BFS if weights of all the edges are taken as one.

80. Thank You !