Data Structures and Algorithms

(ESO207)

Lecture 27
• Quick revision of Depth First Search (DFS) Traversal
• An O():algorithm for biconnected components of a graph

1
 Quick revision of
Depth First Search (DFS) Traversal

2
 DFS traversal of G
DFS(v)
{ Visited(v)  true; DFN[v]  dfn ++;
For each neighbor w of v
{ if (Visited(w) = false)
{ DFS(w) ;
……..;
}
……..;
}
}

DFS-traversal(G)
{
dfn  0;
For each vertex vϵ V { Visited(v) false }
For each vertex v ϵ V { If (Visited(v ) = false) DFS(v) }
}
3
 DFN number

DFN[x] :
y v The number at which x gets visited during DFS
1 0
traversal.
10 w
f 2
3
b
4h 12 11 d
g
5 r
u
8

6 9z
s 7
c

4
 DFS(v) computes a tree rooted at v
If x is ancestor of y then
y v DFN[x] <? DFN[y]
w
f Question: Is a DFS tree unique ?
b Answer: No.
h d
g

r Question:
u
Can any rooted tree be obtained through
z DFS ?
s Answer: No.
c

A DFS tree rooted at v

5
 Always remember
this picture

non-tree edge  back edge

A DFS representation
of the graph
6
Verifying bi-connectivity of a graph

An O() time algorithm

A single DFS traversal

7
 An O() time algorithm

• A formal characterization of the problem.

(articulation points)

• Exploring relationship between articulation point & DFS tree.

• Using the relation cleverly to design an efficient algorithm.

8
 This graph is NOT biconnected
y v

w
f
b
h d
g
The removal of any of {v,f,u} can destroy
u r connectivity.

z v,f,u are called the articulation points of G.

s
c

9
 A formal definition of articulaton point

Definition: A vertex x is said to be articulation point if

u,v different from x
such that every path between u and v passes through x.

u x v

Observation: A graph is biconnected if none of its vertices is an articulation point.

AIM:
Design an algorithm to compute all articulation points in a given graph.

10
 Some observations

v • A leaf node can never be an a.p. ?

• Root is an a.p. iff it has two or more

children.

What about an internal

node ?

11
 Necessary and Sufficient condition
for x to be articulation point
root
<5 Theorem1:
An internal node x is articulation point iff
?z x has at least one child y s.t.
no back edge from subtree(y) to ancestor of x.

 No back edge from subtree(y) going to a

x 5 vertex “higher” than x.

y 6
How to define the notion
“higher” than x ?

9 Use DFN numbering

12
 Necessary and Sufficient condition
for x to be articulation point
root
<5 Theorem1:
An internal node x is articulation point iff
?z x has at least one child y s.t.
no back edge from subtree(y) to ancestor of x.
Invent a new
function
x 5 High_pt(v):
DFN of the highest ancestor of v
y 6 to which there is a back edge from subtree(v).

Theorem2:
An internal node x is articulation point iff
it has a child, say y, in DFS tree such that
9 High_pt(y) ? DFN(x).
≥
13
Theorem2:
An internal node x is articulation point iff
it has a child, say y, in DFS tree such that
High_pt(y) ≥ DFN(x).

Good !
But how to transform this Theorem
into an efficient algorithm for
articulation points ?

In order to compute High_pt(v) of a vertex v,

we have to traverse the adjacency lists of all vertices of subtree T(v).
 O() time in the worst case to compute High_pt(v) of a vertex v.
 O() time algorithm 
14
 How to compute High_pt(v) efficiently ?
root
Question: Can we express High_pt(v) in terms of

its children and proper ancestors?

Exploit
v recursive structure of
DFS tree.

15
 How to compute High_pt(v) efficiently ?
root
Question: Can we express High_pt(v) in terms of

its children and proper ancestors?

High_pt(v) =
min High_pt(w) If w=child(v)
v If w = proper
DFN(w)
ancestor of v
(v,w) ϵ E

16
 The novel algorithm
Output : an array AP[] s.t.
AP[v]= true if and only if v is an articulation point.

17
 Algorithm for articulation points in a graph G
DFS(v)
{ Visited(v)  true; DFN[v]  dfn ++; High_pt[v]∞ ;
For each neighbor w of v
{ if (Visited(w) = false)
{ DFS(w) ; Parent(w)  v;

……..;
……..;
}

……..;
}
}
DFS-traversal(G)
{ dfn  0;
For each vertex vϵ V { Visited(v) false; }
AP[v] false
For each vertex v ϵ V { If (Visited(v ) = false) DFS(v) }
}
18
 Algorithm for articulation points in a graph G
DFS(v)
{ Visited(v)  true; DFN[v]  dfn ++; High_pt[v]∞ ;
For each neighbor w of v
{ if (Visited(w) = false)
{ Parent(w) v; DFS(w);

……..;
High_pt(v)  min( High_pt(v) , High_pt(w) );

……..;
If High_pt(w) ≥ DFN[v] AP[v]  true
}
Else if ( Parent(v) ≠ w )
……..; High_pt(v)  min( DFN(w) , High_pt(v) )
}
}
DFS-traversal(G)
{ dfn  0;
For each vertex vϵ V { Visited(v) false; }
AP[v] false
For each vertex v ϵ V { If (Visited(v ) = false) DFS(v) }
}
19
 Conclusion

Theorem2 : For a given graph G=(V,E), all articulation points can be

computed in O() time.

20
 Data Structures

Range of
Lists: (arrays, linked lists) efficient functions

Binary Heap

Simplicity
Binary Search Trees

21
 Heap
Definition: a tree data structure where :
¿
value stored in a node ? value stored in each of its children.

7 11

13 71 9 18 23

37 19 21 47

43
22
 Operations on a heap
Query Operations
• Find-min: report the smallest key stored in the heap.

Update Operations
• CreateHeap(H) : Create an empty heap H.
• Insert(x,H) : Insert a new key with value x into the heap H.
• Extract-min(H) : delete the smallest key from H.
• Decrease-key(p, ∆, H) : decrease the value of the key p by amount ∆.
• Merge(H1,H2) : Merge two heaps H1 and H2.

23
 Why heaps when we can use a binary search tree ?

Compared to binary search trees, a heap is usually

-- much simpler and

-- more efficient

24
 Existing heap data structures

• Binary heap

• Binomial heap

• Fibonacci heap

• Soft heap

25
 Can we implement
a binary tree using an array ?

Yes.
In some special cases

26
 fundamental question
Question: What does the implementation of a tree data structure require ?

Answer: a mechanism to
• access parent of a node
• access children of a node.

27
A complete binary tree

A complete binary of 12 nodes.

28
 A complete binary tree
Can you see a relationship Level nodes
between label of a node 0 0 1
and labels of its children ?

1 2 1 2

3 4 5 6 2 4

7 8 9 10 11

Think over it before next lecture.

29