Data Structures Alorigthm Analysis

1. 1
Chapter 9 : Graph
(Minimum Spanning Trees)
Text: Read Weiss, §9.5

2. Minimum Spanning Tree
• A minimum spanning tree
of an undirected graph G is a
tree formed from graph
edges that connects all the
vertices of G at a lowest
cost.
• # of edges in a MST is |V|-1.
• If an edge e not in a MST T
is added, a cycle is created.
The removal of an edge from
a cycle reinstates the
spanning tree property. As
MST is created, if minimum
cost edge not creating cycles
is selected, then it’s a MST.
So, greed works for MST
problem.
2

3. Prim’s Algorithm
• Proceed in stages. In each stage, find a new
vertex to add to the tree already formed by
choosing an edge (u, v) such that the cost of
(u, v) is the smallest among all the edges
where u is in the tree and v is not.
• Prim’s algorithm for MSTs is essentially
identical to Dijkstra’s for shortest paths.
• Update rule is even simpler: after a vertex is
picked, for each unknown w adjacent to v,
dw=min(dw, cv,w).
3

4. Prim’s Algorithm – Example I
4

5. Prim’s Algorithm – Example II
5

6. Prim’s Algorithm – Example III
6

7. Prim’s Algorithm – Example IV
7

8. Prim’s Algorithm – Time
Complexity
• The running time is O(|V|2) (|V| iterations in
each of which a sequential scan is performed to
find the minimum cost unknown edge) without
heaps, which is optimal for dense graphs.
• O(|E|*log|V|) (an underlying binary heap with
|V| elements is used, and |V| deleteMin (for
picking min cost vertex) and at most |E|
decreaseKey (for updates) are performed each
taking O(log|V|) time) using binary
heaps,which is good for sparse graphs
8

9. Kruskal’s Algorithm
• A second greedy strategy is continually to
select the edges in order of smallest weight
and accept an edge if it does not cause a
cycle.Formally, Kruskal's algorithm maintains
a forest - a collection of trees. Initially, there
are |V| single-node trees. Adding an edge
merges two trees into one. When the
algorithm terminates, there is only one tree,
and this is the minimum spanning tree.
9

10. An example run of Kruskal’s Algorithm
10

11. 11
// Create the list of all edges E
solution = { } // will include the list of MST edges
while ( more edges in E) do
// Selection
select minimum weight(cost) edge
remove edge from E
// Feasibility
if (edge closes a cycle with solution so far)
then reject edge
else add edge to solution
// Solution check
if |solution| = |V | - 1 return solution
Kruskal’s Algorithm: Pseudo Code I

12. Kruskal’s
Algorithm:
Pseudo Code II
12
The worst-case running
time of this algorithm is
O(|E|log|E|), which is
dominated by the heap
operations. Notice that
since |E| = O(|V|2), this
running time is actually
O(|E| log |V|). In practice,
the algorithm is much
faster.