Heaps. A complete binary tree can be easily stored in an array - place the root in position 1 (for convenience)

Transcription

1 Binary heap data structure Heaps A binary heap is a special kind of binary tree - has a restricted structure (must be complete) - has an ordering property (parent value is smaller than child values) Used in the following applications - Priority queue implementation: supports enqueue and deletemin operations in O(log N) - Heap sort: another O(N log N) sorting algorithm. Binary Heap: Structure Property Complete binary tree: a tree that is completely filled - every level except the last is completely filled. - the bottom level is filled left to right (the leaves are as far left as possible). Complete Binary Trees A complete binary tree can be easily stored in an array - place the root in position 1 (for convenience) Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 1

2 Complete Binary Trees : Properties In the array representation: - put root at location 1 - use an int variable (size) to store number of nodes - for a node at position i: left child at position 2i (if 2i <= size, else i is leaf) right child at position 2i+1 (if 2i+1 <= size, else i is leaf) parent is in position floor(i/2) (or use integer division) Binary Heap: Ordering Property In a heap, if X is a parent of Y, value(x) is less than or equal to value(y). - the minimum value of the heap is always at the root. Binary Heap: operations constructor, destructor isempty() (returns bool) makeempty() insert(x) findmin() (returns ItemType) deletemin() Goal: logarithmic time (O(log n)) or better Must maintain heap properties after each operation Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 2

3 CS Data Structures Heap: insert(x) First: add a node to tree. - must be at next available location, size+1, in order to maintain a complete tree. Now maintain the ordering property: - if x is greater than its parent: done - else swap with parent - repeat Called percolate up or reheap up preserves ordering property O(log n), work is proportional to path length Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 3

4 Heap: deletemin() Minimum is at the root, removing it leaves a hole. The last element in the tree must be relocated: - move last element up to the root - find smaller of the two children - if the smaller child is smaller than the parent: swap it with the parent, repeat - otherwise, we are done Called percolate down or reheap down preserves ordering property O(log n), work is proportional to path length Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 4

5 Heap: deletemin() Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 5

6 Heapsort Heapsort is a comparison-based sorting algorithm. Heapsort is part of the selection sort family The heapsort algorithm can be divided into two parts. In the first step, a heap is built out of the data. The heap is often placed in an array with the layout of a complete binary tree. The complete binary tree maps the binary tree structure into the array indices; each array index represents a node; the index of the node's parent, left child branch, or right child branch are simple expressions. In the second step, a sorted array is created by repeatedly removing the largest element from the heap (the root of the heap), and inserting it into the array. The heap is updated after each removal to maintain the heap. Once all objects have been removed from the heap, the result is a sorted array. Heapsort Space analysis: - currently two arrays are needed: - one for heap, one for sorted list. If we use a Max heap (parent is always greater than children) then we can re-use the empty part of array for the sorted elements. Then we need only one array. Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 6

7 Sample Run Start with unordered array of data. Array representation: Binary tree representation: Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 7

8 Heapify the binary tree Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 8

9 Step 2 perform n 1 deletemax(es), and replace last element in heap with first, then re-heapify. Place deleted element in the last nodes position. Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 9

10 Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 10

11 Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 11

12 Conclusion 1st Step- Build heap, O(n) time complexity 2nd Step perform n deletemax operations, each with O(log(n)) time complexity total time complexity = O(n log(n)) Pros: fast sorting algorithm, memory efficient, especially for very large values of n. Cons: slower of the O(n log(n)) sorting algorithms Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 12

13 Example heapsort.h /* * heapsort.h * * * Author: Husain Gholoom */ #ifndef HEAPSORT_H_ #define HEAPSORT_H_ #include <iostream.h> const int MAX = 11; class array private : int arr[max] ; int count ; public : array( ) ; void add ( int num ) ; void makeheap(int ) ; void heapsort( ) ; void display( ) ; } ; #endif /* HEAPSORT_H_ */ Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 13

14 heapsortimp.cpp #include <iostream.h> using namespace std; #include "heapsort.h" array :: array( ) count = 0 ; for ( int i = 0 ; i < MAX ; i++ ) arr[max] = 0 ; } void array :: add ( int num ) if ( count < MAX ) arr[count] = num ; count++ ; } else cout << "\narray is full" << endl ; } void array :: makeheap(int c) for ( int i = 1 ; i < c ; i++ ) int val = arr[i] ; int s = i ; int f = ( s - 1 ) / 2 ; while ( s > 0 && arr[f] < val ) arr[s] = arr[f] ; s = f ; f = ( s - 1 ) / 2 ; } arr[s] = val ; } } void array :: heapsort( ) for ( int i = count - 1 ; i > 0 ; i-- ) int ivalue = arr[i] ; arr[i] = arr[0] ; arr[0]=ivalue; makeheap(i); } } void array :: display( ) for ( int i = 0 ; i < count ; i++ ) cout << arr[i] << "\t" ; cout << endl ; } Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 14

15 heapsortdriver.cpp #include<iostream> using namespace std; #include "heapsort.h" int main( ) array a ; a.add ( 21 ) ; a.add ( 15 ) ; a.add ( 25 ) ; a.add ( 3 ) ; a.add ( 5 ) ; a.add ( 12 ) ; a.add ( 7 ) ; a.add ( 19 ) ; a.add ( 45 ) ; a.add ( 2 ) ; a.add ( 9 ) ; a.makeheap(11) ; cout << "\nheap Sort.\n" ; cout << "\nbefore Sorting:\n" ; a.display( ) ; a.heapsort( ) ; cout << "\nafter Sorting:\n" ; a.display( ) ; } Sample Run Heap Sort. Before Sorting: After Sorting: Fall 2017 Husain Gholoom - Lecturer in Computer Science Page 15