Midterm test on March 10, 2016
We will have a 2 hour midterm test on March 10 2016 during the
lecture time.
Trees
1
CS 2468: Assignment 2
Due Week 9, Thursday (March 17)
Drop a hard copy in Mail Box 75 or hand in during the lecture
(a) Design an algorithm which takes a root r of a binary tree
(class Bnode) as input and tests if the binary tree rooted
at r is a complete binary tree.
(b) Implement your algorithm in Java
(c) Test your Java program using examples of the following
cases:
1.
2.
3.
4.
A case, where root r is NULL
A case, where root r has no children
A case, where there are 8 nodes in the tree which is a
complete binary tree
A case, where there are 8 nodes in the tree which is not a
complete binary tree
Trees
2
Complete Binary Trees
A complete binary
tree is a binary tree in
which every level,
except possibly the
last, is completely
filled, and all nodes
are as far left as
possible.
1
2
3
4
5
6
A binary tree of height 3 has the first p leaves at
the bottom for p=1, 2, …, 8=23.
Priority Queues
3
Array-Based Representation of
Binary Trees
• nodes are stored in an array
1
A
…
2
3
B

D
let rank(node) be defined as follows:



4
rank(root) = 1
if node is the left child of parent(node),
rank(node) = 2*rank(parent(node))
if node is the right child of parent(node),
rank(node) = 2*rank(parent(node))+1
Trees
5
E
6
7
C
F
10
J
11
G
H
4
Array-Based Representations
• How many cells can be wasted with array based
representation?
Trees
5
Linked Structure for Binary Trees
•
A node is represented by
an object storing
–
–
–
–
•

Element
Parent node
Left child node
Right child node
B
Node objects implement
the Position ADT

B
A

A
D
C
D

E

C
Trees


E
6
Linked Structure for Binary Trees
•
A node is represented by
an object storing
–
–
–
–
•

Element
Parent node
Left child node
Right child node
B
Node objects implement
the Position ADT

B
A

A
D

D
C
F
D


E
C
G
Trees




7
G

Full Binary Tree
• A full binary tree:
– All the leaves are at the bottom level
– All nodes which are not at the bottom level have two children.
– A full binary tree of height h has 2h leaves and 2h-1 internal
nodes.
1
3
2
4
5
6
7
A full binary tree of height 2
This is not a full binary tree.
Trees
8
Part-D1
Priority Queues
Priority Queues
9
Priority Queue ADT
• A priority queue stores a
collection of entries
• Each entry is a pair
(key, value)
• Main methods of the Priority
Queue ADT
• Additional methods
– min()
returns, but does not remove, an
entry with smallest key
– size(), isEmpty()
– insert(k, x)
inserts an entry with key k and
value x
– removeMin()
removes and returns the entry
with smallest key
• Applications:
Priority Queues
– Standby flyers
– Auctions
– Stock market
10
Entry ADT
• An entry in a priority
queue is simply a keyvalue pair
• Priority queues store
entries to allow for
efficient insertion and
removal based on keys
• Methods:
• As a Java interface:
– key(): returns the key for
this entry
– value(): returns the value
associated with this entry
/**
* Interface for a key-value
* pair entry
**/
public interface Entry {
public Object key();
public Object value();
}
Priority Queues
11
Comparator ADT
• A comparator encapsulates
the action of comparing two
objects according to a given
total order relation
• A generic priority queue uses
an auxiliary comparator
• The comparator is external to
the keys being compared
• When the priority queue
needs to compare two keys, it
uses its comparator
• The primary method of the
Comparator ADT:
– compare(a, b): Returns an
integer i such that i < 0 if a < b, i
= 0 if a = b, and i > 0 if a > b; an
error occurs if a and b cannot
be compared.
Priority Queues
12
Priority Queue Sorting
• We can use a priority queue
to sort a set of comparable
elements
1. Insert the elements one by
one with a series of insert
operations
2. Remove the elements in
sorted order with a series of
removeMin operations
• The running time of this
sorting method depends on
the priority queue
implementation
Algorithm PQ-Sort(S, C)
Input sequence S, comparator C
for the elements of S
Output sequence S sorted in
increasing order according to C
P  priority queue with
comparator C
while S.isEmpty ()
e  S.removeFirst ()
P.insert (e, 0)
while P.isEmpty()
e  P.removeMin().key()
S.insertLast(e)
Priority Queues
13
Sequence-based Priority Queue
• Implementation with an
unsorted list
4
5
2
3
• Implementation with a
sorted list
1
1
• Performance:
– insert takes O(1) time since
we can insert the item at
the beginning or end of the
sequence
– removeMin and min take
O(n) time since we have to
traverse the entire
sequence to find the
smallest key
2
3
4
5
• Performance:
Priority Queues
– insert takes O(n) time since
we have to find the place
where to insert the item
– removeMin and min take
O(1) time, since the
smallest key is at the
beginning
14
Selection-Sort
• Selection-sort is the variation of PQ-sort where the
priority queue is implemented with an unsorted list
• Running time of Selection-sort:
1. Inserting the elements into the priority queue with n insert
operations takes O(n) time
2. Removing the elements in sorted order from the priority queue
with n removeMin operations takes time proportional to
1 + 2 + …+ n-1
• Selection-sort runs in O(n2) time
Priority Queues
15
Selection-Sort Example
Input:
Sequence S
(7,4,8,2,5,3,9)
Priority Queue P
()
Phase 1
(a)
(b)
..
.
(g)
(4,8,2,5,3,9)
(8,2,5,3,9)
..
..
.
.
()
(7)
(7,4)
Phase 2
(a)
(b)
(c)
(d)
(e)
(f)
(g)
(2)
(2,3)
(2,3,4)
(2,3,4,5)
(2,3,4,5,7)
(2,3,4,5,7,8)
(2,3,4,5,7,8,9)
(7,4,8,5,3,9)
(7,4,8,5,9)
(7,8,5,9)
(7,8,9)
(8,9)
(9)
()
(7,4,8,2,5,3,9)
Priority Queues
Running time:
1+2+3+…n1=O(n2).
No advantage
is shown by
using unsorted
list.
16
Complete Binary Trees
A complete binary
tree is a binary tree in
which every level,
except possibly the
last, is completely
filled, and all nodes
are as far left as
possible.
1
2
3
4
5
6
A binary tree of height 3 has the first p leaves at
the bottom for p=1, 2, …, 8=23.
Priority Queues
17
Complete Binary Trees
Once the number of
nodes in the complete
binary tree is fixed,
the tree is fixed.
For example, a
complete binary tree
of 15 node is shown
in the slide. A CBT of
14 nodes is the one
without node 8.
1
2
3
4
5
6
7
8
A CBT of 13 node is
the one without
nodes 7 and 8.
A binary tree of height 3 has the first p leaves at
the bottom for p=1, 2, …, 8=23.
Priority Queues
18
Heaps
• A heap is a binary tree storing • The last node of a heap is
keys at its nodes and
the rightmost node of
satisfying the following
depth h
properties:
• Root has the smallest key
– Heap-Order: for every node v
other than the root,
key(v)  key(parent(v))
– Complete Binary Tree: let h be
the height of the heap
• for i = 0, … , h - 1, there are
2i nodes of depth i
• at depth h - 1, the internal
nodes are to the left of the
external nodes
A full binary without the last few nodes
at the bottom on the right.
Priority Queues
2
5
9
6
7
last node
19
Height of a Heap
• Theorem: A heap storing n keys has height O(log n)
Proof: (we apply the complete binary tree property)
– Let h be the height of a heap storing n keys
– Since there are 2i keys at depth i = 0, … , h - 1 and at least one key at
depth h, we have n  1 + 2 + 4 + … + 2h-1 + 1=2h.
– Thus, n  2h , i.e., h  log n
depth keys
0
1
1
2
h-1
2h-1
h
1
Priority Queues
20
Heaps and Priority Queues
•
•
•
•
We can use a heap to implement a priority queue
We store a (key, element) item at each internal node
We keep track of the position of the last node
For simplicity, we show only the keys in the pictures
(2, Sue)
(5, Pat)
(9, Jeff)
(6, Mark)
(7, Anna)
Priority Queues
21
Insertion into a Heap
• Method insertItem of the
priority queue ADT
corresponds to the
insertion of a key k to the
heap
• The insertion algorithm
consists of three steps
– Create the node z (the new
last node). Store k at z
– Put z as the last node in the
complete binary tree.
– Restore the heap-order
property, i.e., upheap
(discussed next)
Priority Queues
2
5
9
6
z
7
insertion node
2
5
9
6
7
z
1
22
Upheap
• After the insertion of a new key k, the heap-order property may be
violated
• Algorithm upheap restores the heap-order property by swapping k along
an upward path from the insertion node
• Upheap terminates when the key k reaches the root or a node whose
parent has a key smaller than or equal to k
• Since a heap has height O(log n), upheap runs in O(log n) time
2
1
5
9
1
7
z
6
5
9
Priority Queues
2
7
z
6
23
An example of upheap
1
2
4
9
5
10
2
3
11
6
14
15
7
16
17
2
2
3
7
Different entries may have the same key. Thus,
a key may appear more than once.
Priority Queues
24
Removal from a Heap
• Method removeMin of the
priority queue ADT
corresponds to the
removal of the root key
from the heap
• The removal algorithm
consists of three steps
– Replace the root key with
the key of the last node w
– Remove w
– Restore the heap-order
property .e.,
downheap(discussed next)
2
5
9
6
7
w
last node
7
5
w
6
9
Priority Queues
new last node
25
Downheap
• After replacing the root key with the key k of the last node, the heaporder property may be violated
• Algorithm downheap restores the heap-order property by swapping key
k along a downward path (always use the child with smaller key) from
the root
• Downheap terminates when key k reaches a leaf or a node whose
children have keys greater than or equal to k
• Since a heap has height O(log n), downheap runs in O(log n) time
7
5
5
6
7
9
6
9
Priority Queues
26
An example of downheap
2
4
17
2
3
9 17 4
17 9
17
5
10
11
6
14
15
7
16
Priority Queues
27
Priority Queue ADT using a heap
• A priority queue stores a
collection of entries
• Each entry is a pair
(key, value)
• Main methods of the
Priority Queue ADT
• Additional methods
– min()
returns, but does not remove,
an entry with smallest key O(1)
– size(), isEmpty() O(1)
– insert(k, x)
inserts an entry with key k
and value x O(log n)
– removeMin()
removes and returns the
entry with smallest key O(log
n)
Priority Queues
Running time of Size(): when
constructing the heap, we keep
the size in a variable. When
inserting or removing a node,
we update the value of the
variable in O(1) time.
isEmpty(): takes O(1) time using
size(). (if size==0 then …)
28
Heap-Sort
• Consider a priority queue
with n items implemented
by means of a heap
– the space used is O(n)
– methods insert and
removeMin take O(log n)
time
– methods size, isEmpty, and
min take time O(1) time
• Using a heap-based
priority queue, we can
sort a sequence of n
elements in O(n log n)
time
• The resulting algorithm is
called heap-sort
• Heap-sort is much faster
than quadratic sorting
algorithms, such as
insertion-sort and
selection-sort
Priority Queues
29
Array-based Heap Implementation
• We can represent a heap with n keys
by means of an array of length n + 1
• For the node at rank i
2
– the left child is at rank 2i
– the right child is at rank 2i + 1
• Links between nodes are not
explicitly stored
• The cell of at rank 0 is not used
• Operation insert corresponds to
inserting at rank n + 1
• Operation removeMin corresponds
to removing at rank n
• Yields in-place heap-sort
• The parent of node at rank i is i/2
Priority Queues
5
6
9
0
7
2
5
6
9
7
1
2
3
4
5
30
Build a heap from an array of n
elements
Priority Queues
31
Build a heap from an array of n
elements
Priority Queues
32
Build a heap from an array of n
elements
Priority Queues
33
Build a heap from an array of n
elements
Priority Queues
34
Build a heap from an array of n
elements
The total running for BUILD-MAX-HEAP(A) is
O(n), where A has n elements.
Priority Queues
35
Build a heap from an array of n
elements
Priority Queues
36
Build a heap from an array of n
elements
Priority Queues
37
Build a heap from an array of n
elements
Priority Queues
38
Analysis
• We visualize the worst-case time of a downheap with a proxy path that
goes first right and then repeatedly goes left until the bottom of the
heap (this path may differ from the actual downheap path)
• Since each node is traversed by at most two proxy paths, the total
number of nodes of the proxy paths is O(n)
• Thus, bottom-up heap construction runs in O(n) time
• Bottom-up heap construction is faster than n successive insertions and
speeds up the first phase of heap-sort
Priority Queues
39
Max heap vs Min heap
• Instead of removeMin(),
we can do removeMax()
If we always want to choose
the one with maximum key
value, we can have a max
heap (instead of Min heap)
Just change the definition of
heap order and everything is
smilar.
Priority Queues
40
Adaptable heap
• Adaptable heap has one
more operation:
replace(location: of x, key)
• Algorithm:
–
–
–
–
k=x.key
X.key=key
If (k>key) then upheap
If (k<key) then downheap
Priority Queues
41
How to know the location of a heap :
11/6
12/7
Array- 14/1
based rep
of the
complete
binary
tree T[]
13/4
15/3
0
location
0
16/2
17/5
11 12 13 14 15
16 17
Key value
1
2
3
5
6
7
Rank of the
node
4
6
5
7
1
2
1
2
3
4
3
4
5
Binary Search Trees
6
7
id-name of a node
42