Transcript Lecture 9

Sorting
Dr. Yingwu Zhu
Heaps
A heap is a binary tree with properties:
1.
It is complete
•
•
Each level of tree completely filled
Except possibly bottom level (nodes in
left most positions)
It satisfies heap-order property
2.
•
Data in each node >= data in children
Heaps

Which of the following are heaps?
A
B
C
Heaps


Maxheap?– by default
Minheap?
Implementing a Heap

What data structure is good for its
implementation?
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
3
2
4
Implementing a Heap

Note the placement of the nodes in the array
0
1
2
3
4
5
Implementing a Heap


In an array implementation children of ith node
are at myArray[2*i+1] and myArray[2*i+2]
Parent of the ith node is at mayArray[(i1)/2]
Basic Heap Operations

Constructor


Empty


Check value of mySize
Retrieve max item


Set mySize to 0, allocate array
Return root of the binary tree, myArray[0]
How about delete max item?

Think about it?
Basic Heap Operations

Delete max item

Max item is the root, replace with last node in tree
Result called a
semiheap



Then interchange root with larger of two children
Continue this with the resulting sub-tree(s)
Semiheap: [1] complete [2] both subtrees are heaps
Implementing Heap
#define CAP 10000
template <typename T>
class Heap {
private:
T myArray[CAP];
int mySize;
private:
void percolate_down(int pos); //percolate down
void percolate_up(int pos); //percolate up
public:
Heap():mySize(0) {}
~Heap();
void deleteMax(); //remove the max element
void insert(const T& item); //insert an item
…
};
Percolate Down Algorithm
1. Set c = 2 * r + 1
2. While c < n do following //what does this mean?
a. If c < n-1 and myArray[c] < myArray[c + 1]
Increment c by 1
b. If myArray[r] < myArray[c]
i. Swap myArray[r] and myArray[c]
ii. set r = c
iii. Set c = 2 * c + 1
else
Terminate repetition
End while
Percolate down



Recursive
Non-recursive
void delete_max()
Basic Heap Operations

Insert an item

What is the basic idea?
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
Percolate Up Algorithm

Why percolate up?



When to terminate the up process?
void Heap<T>::percolate_up()
void Heap<T>::insert(const T& item)
How to do remove?


Remove an item from the heap?
Question: A leaf node must be less or
equal than any internal node in a heap?
HeapSort


What is the basic idea?
Discussions and comments?
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
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 myArray[r] , … myArray[n-1]
End for
Puts largest element at root
Do you understand it? Think why?
Heapsort

Why?


Heap is a recursive ADT
Semiheap  heap: from bottom to up

Percolate down for this conversion
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
Heapsort

Again swap root with rightmost leaf

Continue this process with shrinking sublist
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
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 1:
a. Interchange x[0] and x[i]
(puts largest element at end)
b. Apply percolate_down to convert
binary tree corresponding to sublist in
x[0] .. x[i-1]
Heapsort


Fully understand how heapsort works!
T(n) = O(nlogn)

Why?
Heap Algorithms in STL


Found in the <algorithm> library
 make_heap()
heapify
 push_heap()
insert
 pop_heap()
delete
 sort_heap()
heapsort
Note program which illustrates these
operations, Fig. 13.1
Priority Queue

A collection of data elements



Items stored in order by priority
Higher priority items removed ahead of lower
Operations







Constructor
Insert
Find, remove smallest/largest (priority) element
Replace
Change priority
Delete an item
Join two priority queues into a larger one
Priority Queue

Implementation possibilities

As a list (array, vector, linked list)


As an ordered list


T(n) for search, removeMax, insert operations
T(n) for search, removeMax, insert operations
Best is to use a heap


T(n) for basic operations
Why?
Priority Queue

STL priority queue adapter uses heap

Note operations in table of Fig. 13.2 in
text, page 751