CSCE 210 Data Structures and Algorithms - PowerPoint PPT Presentation

1 / 96
About This Presentation
Title:

CSCE 210 Data Structures and Algorithms

Description:

Title: CSCI 210 Data Structures & Algorithms Author: Dr. Amr Goneid Last modified by: a.goneid Created Date: 6/10/2001 5:46:48 PM Document presentation format – PowerPoint PPT presentation

Number of Views:428
Avg rating:3.0/5.0
Slides: 97
Provided by: Dr937
Category:

less

Transcript and Presenter's Notes

Title: CSCE 210 Data Structures and Algorithms


1
CSCE 210Data Structures and Algorithms
  • Prof. Amr Goneid
  • AUC
  • Part 10. Graphs

2
Graphs

3
Graphs
  • Basic Definitions
  • Paths and Cycles
  • Connectivity
  • Other Properties
  • Representation
  • Examples of Graph Algorithms
  • Graph Traversal
  • Shortest Paths
  • Minimum Cost Spanning Trees

4
1. Basic Definitions
  • A graph G (V,E) can be defined
  • as a pair (V,E) , where V is a set
  • of vertices, and E is a set of
  • edges between the vertices
  • E (u,v) u, v ? V. e.g.
  • V A,B,C,D,E,F,G
  • E ( A,B),(A,F),(B,C),(C,G),(D,E),(D,G),(E,F),(F
    ,G)
  • If no weights are associated with the edges, an
    edge is
  • either present(1) or absent (0).

5
Basic Definitions
  • A graph is like a road map. Cities are vertices.
    Roads from city to city are edges.
  • You could consider junctions to be vertices, too.
    If you don't want to count them as vertices, a
    road may connect more than two cities. So
    strictly speaking you have hyperedges in a
    hypergraph.
  • If you want to allow more than one road between
    each pair of cities, you have a multigraph,
    instead.

6
Basic Definitions
  • Adjacency If vertices u,v have
  • an edge e (u,v) u, v ? V then
  • u and v are adjacent.
  • A weighted graph has a weight
  • associated with each edge.
  • Undirected Graph is a graph in which the
    adjacency is
  • symmetric, i.e., e (u,v) (v,u)
  • A Sub-Graph has a subset of the vertices and the
  • edges

3
2
2
1
5
4
2
1
7
Basic Definitions
3
  • Directed Graph is a graph in which
  • adjacency is not symmetric,
  • i.e., (u,v) ? (v,u)
  • Such graphs are also called
  • Digraphs
  • Directed Weighted Graph
  • A directed graph with a weight
  • for each edge. Also called a network.

2
2
1
5
4
2
1
8
2. Paths Cycles
  • Path A list of vertices of a graph where each
    vertex
  • has an edge from it to the next vertex.
  • Simple Path A path that repeats no vertex.
  • Cycle A path that starts and ends at the same
    vertex
  • and includes other vertices at most once.

9
Directed Acyclic Graph (DAG)
  • Directed Acyclic Graph (DAG) A directed graph
    with
  • no path that starts and ends at the same vertex

10
Hamiltonian Cycle
  • Hamiltonian Cycle
  • A cycle that includes all other vertices only
    once,
  • e.g. D,B,C,G,A,F,E,D
  • Named after Sir William Rowan Hamilton (1805
    1865)
  • The Knights Tour problem is a Hamiltonian cycle
    problem

Icosian Game
11
Hamiltonian Cycle Demo
  • A Hamiltonian Cycle is a cycle that visits each
    node exactly once. Here we show a Hamiltonian
    cycle on a 5-dimensional hypercube. It starts by
    completely traversing the 4-dimensional hypercube
    on the left before reversing the traversal on the
    right subcube.
  • Hamiltonian cycles on hypercubes provide
    constructions for Gray codes orderings of all
    subsets of n items such that neighboring subsets
    differ in exactly one element.
  • Hamilitonian cycle is an NP-complete problem, so
    no worst-case efficient algorithm exists to find
    such a cycle.
  • In practice, we can find Hamiltonian cycles in
    modest-sized graphs by using backtracking with
    clever pruning to reduce the search space.

12
Hamiltonian Cycle Demo
  • http//www.cs.sunysb.edu/skiena/combinatorica/an
    imations/ham.html
  • Hamiltonian Cycle Demo

13
Euler Circuit
  • Leonhard Euler Konigsberg Bridges
  • (1736) (not
    Eulerian)
  • Euler Circuit
  • A cycle that includes every edge once.
  • Used in bioinformatics to reconstruct the DNA
    sequence from its fragments

14
Euler Circuit Demo
  • An Euler circuit in a graph is a
  • traversal of all the edges of the
  • graph that visits each edge
  • exactly once before returning
  • home. A graph has an Euler circuit
  • if and only if all its vertices are that
  • of even degrees.
  • It is amusing to watch as the Euler circuit finds
    a way back home to a seemingly blocked off start
    vertex. We are allowed (indeed required) to visit
    vertices multiple times in an Eulerian cycle, but
    not edges.

15
Euler Circuit Demo
  • http//www.cs.sunysb.edu/skiena/combinatorica/ani
    mations/euler.html
  • Euler Circuit Demo

16
3. Connectivity
  • Connected Graph An undirected graph with a path
  • from every vertex to every other vertex
  • A Disconnected Graph may have several connected
  • components
  • Tree A connected Acyclic graph

17
Connected Components Demo
  • What happens when you start with an empty graph
    and add random edges between vertices?
  • As you add more and more edges, the number of
    connected components in the graph can be expected
    to drop, until finally the graph is connected.
  • An important result from the theory of random
    graphs states that such graphs very quickly
    develop a single giant'' component which
    eventually absorbs all the vertices.

18
Connected Components Demo
  • http//www.cs.sunysb.edu/skiena/combinatorica/ani
    mations/concomp.html
  • Randomly Connected Graph Demo

19
Connectivity
  • Articulation Vertex if removed with all of its
    edges will
  • cause a connected graph to be disconnected, e.g.,
    G
  • and D are articulation vertices

20
Connectivity
  • Degree Of a vertex,
  • the number of edges connected to
  • it.
  • Degree Of a graph,
  • the maximum degree of any vertex
  • (e.g. B has degree 2, graph has degree 3).
  • In a connected graph the sum of the degrees is
    twice
  • the number of edges, i.e

21
Connectivity
  • In-Degree/Out-Degree the number of edges coming
  • into/emerging from a vertex in a connected graph
    (e.g.
  • G has in-degree 3 and out-degree 1).

22
Connectivity
  • Complete Graph
  • There is an edge between
  • every vertex and every
  • other vertex. In this case,
  • the number of edges is
  • maximum
  • Notice that the minimum number of edges for a
  • connected graph ( a tree in this case) is (V-1)

23
Density (of edges)
  • Density of a Graph
  • Dense Graph
  • Number of edges is close to Emax V(V-1)/2.
  • So, E ?(V2) and D is close to 1
  • Sparse Graph
  • Number of edges is close to Emin (V-1).
  • So, E O(V)

24
4. Other Properties
  • Planar Graph
  • A graph that can be drawn in
  • the plain without edges
  • crossing

Non-Planar
25
Other Properties
  • Graph Coloring
  • To assign color (or any distinctive mark) to
    vertices
  • such that no two adjacent vertices have the same
    color.
  • The minimum number of colors needed is called the
  • Chromatic Order of the graph ?(G).
  • For a complete graph, ?(G) V.

2
1
3
4
26
Other Properties
  • An Application
  • Find the number of exam slots for 5 courses. If a
    single
  • student attends two courses, an edge exists
    between them.

EE
Slot Courses
1 (red) CS
2 (Green) EE, Econ, Phys
3 (Blue) Math
CS
Math
Phys
Econ
27
5. Representation
  • Adjacency Matrix
  • V x V Matrix a(i,j)
  • a(i,j) 1 if vertices (i) and (j) are adjacent,
    zero otherwise. Usually self loops are not
    allowed so that a(i,i) 0.
  • For undirected graphs, a(i,j) a(j,i)
  • For weighted graphs, a(i,j) wij

A B C D
A 0 1 1 0
B 1 0 1 0
C 1 1 0 1
D 0 0 1 0
28
Representation
  • The adjacency matrix is appropriate for dense
    graphs
  • but not compact for sparse graphs.
  • e.g., for a lattice graph, the degree
  • of a vertex is 4, so that E 4V.
  • Number of 1s to total matrix size
  • is approximately 2 E / V2 8 / V.
  • For V gtgt 8, the matrix is dominated by zeros.

29
Representation
  • Adjacency List
  • An array of vertices with pointers
  • to linked lists of adjacent nodes, e.g.,
  • The size is O(E V) so it is compact for sparse
    graphs.

B
A
C
B
A
C
C
A
B
D
D
C
30
6. Examples of Graph Algorithms
  • Examples of Graph Algorithms
  • Graph Traversal
  • Shortest Paths
  • Minimum Cost Spanning Trees

31
6.1 Graph TraversalDepth-First Search (DFS)
  • Visits every node in the graph by following node
    connections in depth.
  • Recursive algorithm.
  • An Array valv records the order in which
    vertices are visited. Initialized to unseen.
  • Any edge to a vertex that has not been seen is
    followed via the recursive call.

32
Algorithm
  • // Assume order 0 initially
  • void DFS()
  • int k int unseen -2
  • // Initialize all to unseen
  • for (k 1 k lt v k) valk unseen
  • // Follow Nodes in Depth
  • for (k 1 k lt v k)
  • if (valk unseen) visit(k)

33
Algorithm (continued)
  • void visit(int k)
  • int t
  • valk order
  • for (t 1 t lt v t)
  • if (akt ! 0)
  • if (valt unseen) visit(t)

34
Example
1

A
start
B
C
G
F
D
E
A B C D E F G
1
VALK
35
Example
1

A
B
C
G
F
2
D
E
A B C D E F G
1 2
VALK
36
Example
1

A
B
C
G
F
3
2
D
E
A B C D E F G
1 2 3
VALK
37
Example
1

A
B
C
G
F
4
3
2
D
E
A B C D E F G
1 2 3 4
VALK
38
Example
1

A
B
C
G
F
4
3
2
D
E
5
A B C D E F G
1 2 3 5 4
VALK
39
Example
1

A
B
C
G
F
4
3
2
D
E
5
6
A B C D E F G
1 2 3 5 6 4
VALK
40
Example
1

A
7
B
C
G
F
4
3
2
D
E
5
6
A B C D E F G
1 2 3 5 6 4 7
VALK
41
Exercises
  • Show how DFS can be used to determine the number
    of connected components in a graph.
  • Explore the non-recursive version of the DFS
    using a stack. What will happen if you use a
    queue instead of the stack?

42
Non-Recursive DFS
  • // Assume unseen -2 and hold -1
  • // Val is set to unseen initially , order
    0
  • Stactltintgt S // A stack of integers
  • void DFS(int k)
  • int t S.push(k)
  • while (! S.stackIsEmpty())
  • S.pop(k) valk order
  • for (t v t gt 1 t--) // Scan from right to
    left
  • if (akt ! 0) if (valt unseen)
  • S.push(t) valt hold

43
Breadth-First Search (BFS)
  • // Replacing the stack by a queue, gives the BFS
    algorithm
  • Queuetltintgt Q // A queue of integers
  • void BFS(int k)
  • int t Q.enqueue(k)
  • while (! Q.queueIsEmpty())
  • Q.dequeue(k) valk order
  • for (t 1 t lt v t) // Scan from left to
    right
  • if (akt ! 0) if (valt unseen)
  • Q.enqueue(t) valt hold

44
Example BFS

1
A
B
C
G
F
4
5
3
2
D
E
6
7
A B C D E F G
1 5 3 6 7 4 5
45
DFS and BFS of a Tree
  • For a tree structure
  • DFS is equivalent to Pre-order traversal
  • BFS is equivalent to Level-order traversal
  • DFS Demo
  • BFS Demo

46
Graph Traversal Demos
  • http//www.cs.sunysb.edu/skiena/combinatorica/ani
    mations/search.html
  • http//www.cosc.canterbury.ac.nz/people/mukundan/d
    sal/GraphAppl.html

47
Exercise
in
  • Model the shown maze
  • as a graph.
  • Show how DFS can be
  • used to find the exit.

out
48
8. A Simple Graph Class
  • To represent a weighted undirected graph with a
    maximum of Vmax vertices and Emax
    Vmax(Vmax-1)/2 edges. The verices are numbered
    0,1,...V-1.
  • The graph is assumed to be on a text file in the
    form of an adjacency matrix. The weights on the
    edges are assumed to be positive integers with
    zero weight indicating the absence of an edge.
  • When loaded from the text file, the weights are
    stored in a 2-D array (AdjMatrix) representing
    the adjacency matrix. Another array (edges)
    stores the non-zero edges in the graph.
  • An edge (u,v,w) existing between nodes (u) and
    (v) with weight (w) is modeled as a class (Edge).

49
Edge Class
  • // File Edge.h
  • // Definition of Edge class
  • ifndef EDGE_H
  • define EDGE_H
  • typedef int weightType // weights are positive
    integers
  • class Edge
  • public
  • int u,v weightType w
  • bool operator lt (const Edge e) return
    (w lt e.w)
  • bool operator lt (const Edge e) return (w
    lt e.w)
  • // end of class Edge declaration
  • endif // EDGE_H

50
Graph Class
  • // File Graphs.h
  • // Graph library header file
  • ifndef GRAPHS_H
  • define GRAPHS_H
  • include ltstringgt
  • include "Edge.h"
  • using namespace std
  • const int Vmax 50 // Maximum number of
    vertices
  • const int Emax Vmax(Vmax-1)/2 // Maximum
    number of edges

51
Graph Class
  • class Graphs
  • public
  • Graphs() // Constructor
  • Graphs() // Destructor
  • // Map vertex number to a name (character)
  • char Vname(const int s) const
  • void getGraph(string fname) // Get Graph from
    text File (fname)
  • void dispGraph( ) const // Display Ajacency
    Matrix
  • int No_of_Verices( ) const // Get number of
    vertices (V)
  • int No_of_Edges( ) const // Get Number of
    Non-zero edges (E)
  • void dispEdges( ) const // Display Graph edges
  • void DFS( ) // Depth First Search Traversal
    (DFS)

52
Graph Class
  • private
  • int V, E // No.of vertices (V) and edges (E)
  • weightType AdjMatrixVmaxVmax // Adjacency
    Matrix
  • Edge edgesEmax // Array of non-zero edges
  • int order // Order of Visit of a node in the
    DFS
  • int valVmax // Array holding order of
    traversal void getEdges() // Get edges from
    adjacency matrix
  • void printEdge(Edge e) const // Output an edge
    (e)
  • void visit(int k) // Node Visit Function for
    DFS
  • endif // GRAPHS_H
  • include "Graphs.cpp"

53
6.2 Shortest Paths(General)
  • In a graph G(V,E), find shortest paths from a
    single source vertex (S) to all other vertices.
  • Edsger Dijkstra published an algorithm to solve
    this problem in 1959.

54
Shortest Paths Dijkstras Algorithm
  • Dijkstras Algorithm for V vertices
  • Uses three arrays
  • - Distancei holds distance from (S) to
  • vertex (i).
  • - Processedi to flag processed vertices.
  • - Viai holds index of vertex from which we
  • can directly reach vertex (i).

55
Initialization
  • Distancei
  • 0 if S i
  • Wsi if (S, i) are adjacent
  • ? otherwise
  • Processedi yes if i S , No otherwise
  • Viai S if (i , S) are adjacent, 0 otherwise

56
Method

closest to S
not yet processed
j
Distancej
Already Processed
Wij
S
i
Distancei
x
z
y
adjacent to j
57
Dijkstras Algorithm
  • Repeat
  • Find j index of unprocessed node closest to (S)
  • Mark (j) as now processed
  • For each node (i) not yet processed
  • if (i) is adjacent to (j) then
  • new_distance Distancej Wij
  • if new_distance lt Distancei then
  • Distancei new_distance
  • Viai j
  • Until all vertices are processed

58
Example
  • Initial Source A

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
59
Example
  • j B

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
60
Example
  • j B i D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
61
Example
  • j E

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
62
Example
  • j E i C

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
63
Example
  • j C

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
64
Example
  • j C i D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
65
Example
  • j D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
66
Example
  • Final

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
A?B A?E?C A?B?D A?E
C
D
35
67
How to print the path?
  • / The function Vname(k) maps a vertex number to
    a name (e.g a character A, B,.. etc). Given the
    via array resulting from Dijkstras algorithm,
    the following recursive function prints the
    vertices on the shortest path from source (s) to
    destination (i).
  • /
  • void GraphsprintPath(int s, int i) const
  • if (i s) cout ltlt Vname(s)
  • else
  • printPath(s,viai) cout ltlt Vname(i)

68
Demo
  • http//www.cs.sunysb.edu/skiena/combinatorica/ani
    mations/dijkstra.html
  • Shortest Paths Demo1
  • Shortest Paths Demo2

69
6.3 Minimum Cost Spanning Trees (a) Spanning Tree
  • Consider a connected undirected graph G(V,E). A
    sub-graph S(V,T) is a spanning tree of the graph
    (G) if
  • V(S) V(G) and T ? E
  • S is a tree, i.e., S is connected and has no
    cycles

70
Spanning Tree

71
Spanning Tree

72
One Graph, Several Spanning Trees

73
Spanning Forest

74
(b) Minimum Cost Spanning Tree(MST)
  • Consider houses A..F connected by
  • muddy roads with the distances
  • indicated. We want to pave some
  • roads such that
  • We can reach a house from
  • any other house via paved roads.
  • The cost of paving is minimum.
  • This problem is an example of
  • finding a Minimum Spanning Tree
  • (MST)

4
G
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
75
Minimum Spanning Tree(MST)
  • Cost
  • For a weighted graph,
  • the cost of a spanning tree
  • is the sum of the weights
  • of the edges in that tree.
  • Minimum Spanning tree
  • A spanning tree of minimum cost
  • For the shown graph, the
  • minimum cost is 22

G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
76
Kruskals Algorithm for MST
  • The algorithm was written by
  • Joseph Kruskal in 1956
  • A Greedy Algorithm
  • Builds the MST edge by edge into a set of edges
    (T). At a given stage, chooses an edge that
    results in minimum increase in the sum of costs
    included so far in (T).
  • The set (T) might not be a tree at all stages of
    the algorithm, but it can be completed into a
    tree iff there are no cycles in (T).

77
Kruskals Algorithm for MST
  • Builds up forests , then joins them in a single
    tree.
  • Constraints
  • - The graph must be connected.
  • - Uses exactly V-1 edges.
  • - Excludes edges that form a cycle.

78
Abstract Algorithm
  • -Form Set E of edges in increasing order of
    costs.
  • - Set MST T empty
  • -Repeat
  • Select an edge (e) from top.
  • Delete edge from E set.
  • Add edge (e) to (T) if it does not form a cycle,
    otherwise, reject.
  • -Until we have V-1 successful edges.

79
Example

Edge u v w accept
1 E F 2
2 A C 3
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
80
Example

Edge u v w accept
1 E F 2 yes
2 A C 3
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
81
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
82
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
83
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
84
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
85
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
86
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5 No
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
87
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5 NO
8 B D 6 yes
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
88
How to test for Cycles?Simple Union- Simple Find
  • Given a set (1,2,..,n initially partitioned into
    n
  • disjoint sets (each element is its own parent)
  • Find (i) return the sub-set that (i) is in (i.e.
    return the parent set of i).
  • Union (k,j) combine the two sub-sets that (j)
    and (k) are in (make k the child of j)
  • Union builds up a tree, while find will search
    for the root of the tree.
  • Cost is O(log n)

89
How to test for Cycles?
  • Represent vertices as Disjoint Sets
  • Initially, each node is its own parent (-1)

A
B
C
D
E
F
G
Let the parent set of u be p(u)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 -1 -1 -1 -1 -1
90
How to test for Cycles?
  • When edge (E,F) is selected, we find that p(E) ?
    p(F). So, we make a union between p(E) and p(F),
    i.e., p(F) becomes the child of p(E). Same for
    edge (A,C)

A
B
C
D
E
F
G
Parent table after selecting (E,F) then (A,C)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 -1 -1 5 -1
91
How to test for Cycles?
  • When (C,E) is selected, we find that P(C) ? P(E).
    This means that the edge will be accepted.
  • Select (A,E), Find will give P(A) P(E) (cycle,
    reject).

D
A
E
F
G
B
C
Parent table after accepting (E,F) then (A,C),
then (C,E), then rejecting (A,E)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 -1 3 5 -1
92
How to test for Cycles?
  • When (C,D) is selected, we find that P(C) ? P(D).
    This means that the edge will be accepted.
  • Select (E,G), Find will give P(E) ? P(G)
    (accept).

G
D
A
E
F
B
C
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 3 3 5 5
Parent table after 5th accepted edge
93
How to test for Cycles?
  • When (D,F) is selected, we find that P(D) P(F).
    This means that the edge will be rejected.
  • Select (B,D), Find will give P(B) ? P(D)
    (accept).

G
D
A
E
F
B
C
A B C D E F G
1 2 3 4 5 6 7
-1 4 1 3 3 5 5
Parent table after 6th accepted edge (Final MST)
94
Kruskals Algorithm
  • Insert edges with weights into a minimum heap
  • Put each vertex in a separate set
  • i 0
  • While ((i lt V-1) (heap not empty))
  • Remove edge (u,v) from heap
  • Find set (j) of connected vertices having (u)
  • Find set (k) of connected vertices having (v)
  • if ( j ! k )
  • i MST i.u u MST i.v v
  • MST i.w w
  • Make a Union between set (j) and set (k)

95
Kruskals Algorithm Demo
  • http//www.cs.sunysb.edu/skiena/combinatorica/an
    imations/mst.html
  • Kruskal's algorithm at work on a graph of
    distances between 128 North American cities.
    Almost imperceptively at first, short edges get
    added all around the continent, slowly building
    forests until the tree is completed.
  • MST (Kruskal) Demo1
  • MST (Kruskal) Demo2

96
Learn on your own about
  • Directed Graphs or Digraphs
  • Edge-List representation of graphs
  • Prims algorithm for Minimum Spanning Trees. The
    algorithm was developed in 1930 by Czech
    mathematician Vojtech Jarník
  • and later independently by
  • computer scientist
  • Robert C. Prim in 1957
  • and rediscovered by
  • Edsger Dijkstra in 1959. Therefore it is also
    sometimes called the DJP algorithm, the Jarník
    algorithm, or the PrimJarník algorithm.
Write a Comment
User Comments (0)
About PowerShow.com