Sorting Dr. Yingwu Zhu

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 >= 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) 1 2 3 4

Implementing a Heap Note the placement of the nodes in the array 1 2 3 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[(i-1)/2]

Implementing Heap #define CAP 10000 template <typename T> class Heap { private: T myArray[CAP]; int mySize; public: Heap():mySize(0) {} ~Heap(); void deleteMax(); //remove the max element void insert(const T& item); //insert an item … };

Basic Heap Operations Constructor Empty Retrieve max item Set mySize to 0, allocate array Empty Check value of mySize Retrieve max item Return root of the binary tree, myArray[0] How about delete max item? Think about it?

Result called a semiheap 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) Semiheap: [1] complete [2] both subtrees are heaps Result called a semiheap

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 Convert to a heap 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] [3] [0] [0] [0] [1] [2] [3] [4] [5]

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 [0] [1] [2] [3] [4] [5] [0] [1] [2] [3] [4] [5]

Heapsort Again swap root with rightmost leaf Continue this process with shrinking sublist [0] [1] [2] [3] [4] [5] [0] [1] [2] [3] [4] [5]

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 Operations 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) T(n) for search, removeMax, insert operations As an ordered list 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