Heap%20and%20Heapsort - PowerPoint PPT Presentation

About This Presentation

Title:

Heap%20and%20Heapsort

Description:

Heap and Heapsort Dr. Yingwu Zhu – PowerPoint PPT presentation

Number of Views:179

Avg rating:3.0/5.0

Slides: 33

Provided by: Yin125

Learn more at: http://fac-staff.seattleu.edu

Category:

more less

Transcript and Presenter's Notes

Title: Heap%20and%20Heapsort

1
Heap and Heapsort

Dr. Yingwu Zhu

2
Heaps

A heap is a binary tree with properties
It is complete
Each level of tree completely filled
Except possibly bottom level (nodes in left most
positions)
It satisfies heap-order property
Data in each node gt data in children

3
Heaps

Which of the following are heaps?

C
B
A
4
Heaps

Maxheap? by default
Minheap?

5
Implementing a Heap

What data structure is good for its
implementation?

6
Implementing a Heap

Use an array or vector, why?
Number the nodes from top to bottom
Number nodes on each row from left to right
Store data in ith node in ith location of array
(vector)

0
1
2
3
4
7
Implementing a Heap

Note the placement of the nodes in the array

0
1
2
3
4
5
8
Implementing a Heap

In an array implementation children of ith node
are at myArray2i1 and myArray2i2
Parent of the ith node is at mayArray(i-1)/2

9
Implementing Heap

define CAP 10000
typedef int T
class Heap private T myArrayCAP
int mySize
public Heap()mySize(0) Heap()
void deleteMax() //remove the max element
void insert(const T item) //insert an
item

10
Basic Heap Operations

Constructor
Set mySize to 0, allocate array
Empty
Check value of mySize
Retrieve max item
Return root of the binary tree, myArray0
How about delete max item?
Think about it?

11
Delete Max Item?
12
Basic Heap Operations

Delete max item
Max item is the root, replace with last node in
tree
Then interchange root with larger of two children
Continue this with the resulting sub-tree(s)
?percolate down
Semiheap 1 complete 2 both subtrees are heaps

13
Implementing Heap

define CAP 10000
typedef int T
class Heap private T myArrayCAP
int mySize
private
void percolate_down(int pos) //percolate
down
public Heap()mySize(0) Heap()
void deleteMax() //remove the max element
void insert(const T item) //insert an
item

14
Percolate Down Algorithm

1. Set c 2 r 1
2. While c lt n do following //what does this
mean?
a. If c lt n-1 and myArrayc lt myArrayc
1 Increment c by 1b. If myArrayr lt
myArrayc i. Swap myArrayr and
myArrayc ii. set r c iii. Set c 2 c
1else Terminate repetitionEnd while

15
Percolate down

Recursive
Non-recursive
void delete_max()

16
Insert an item into the heap

What is the basic idea?

17
Basic Heap Operations

Insert an item
Amounts to a percolate up routine
Place new item at end of array
Interchange with parent so long as it is greater
than its parent

00
0 1 2 3 4 5 6
18
Percolate Up Algorithm

Why percolate up?
When to terminate the up process?
void Heappercolate_up()
void Heapinsert(const T item)

19
How to do remove?

Remove an item from the heap?
Hint question A leaf node must be less or equal
than any internal node in a heap?

20
HeapSort

What is the basic idea?
Discussions and comments?

21
Heapsort

Given a list of numbers in an array
Stored in a complete binary tree
Convert to a heap
Begin at last node not a leaf pos (size-2)/2?
Apply percolated down to this subtree
Continue

0
1
0
0
3
0
1
2
3
4
5
22
Heapsort

Algorithm for converting a complete binary tree
to a heap called "heapify"For r (n-1-1)/2
down to 0
apply percolate_down to the subtree in
myArrayr , myArrayn-1End for
Puts largest element at root
Do you understand it? Think why?

23
Heapsort

Why?
Heap is a recursive ADT
Semiheap ? heap from bottom to up
Percolate down for this conversion

24
Heapsort

Now swap element 1 (root of tree) with last
element
This puts largest element in correct location
Use percolate down on remaining sublist
Converts from semi-heap to heap

25
Heapsort

Again swap root with rightmost leaf
Continue this process with shrinking sublist

26
Summary of HeapSort

Step 1 put the data items into an array
Step 2 Heapify this array into a heap
Step 3 Exchange the root node with the last
element and shrink the list by pruning the last
element.
Now it is a semi-heap
Apply percolate-down algorithm
Go back step 3

27
Heapsort Algorithm

1. Consider x as a complete binary tree, use
heapify to convert this tree to a heap
2. for i n-1 down to 1a. Interchange x0 and
xi (puts largest element at end)b. Apply
percolate_down to convert binary tree
corresponding to sublist in x0 .. xi-1

28
Heapsort