CS 261 Data Structures

Transcription

1 CS61 Data Structures CS 61 Data Structures Priority Queue ADT & Heaps

2 Goals Introduce the Priority Queue ADT Heap Data Structure Concepts

3 Priority Queue ADT Not really a FIFO queue misnomer!! Associates a priority with each element in the collecgon: First element has the highest priority (typically, lowest value) ApplicaGons of priority queues: To do list with prioriges Graph Searching AcGve processes in an OS

4 Priority Queue ADT: Interface Next element returned has highest priority void add(); TYPE getmin(); void removemin();

5 Priority Queue ADT: ImplementaGon Heap: has completely different meanings 1. Classic data structure used to implement priority queues. Memory space used for dynamic allocagon We will study the data structure (not dynamic memory allocagon)

6 Priority Queue ADT: ImplementaGon Binary Heap data structure: a complete binary tree in which every node s value is less than or equal to the values of its children (min heap) Review: a complete binary tree is a tree in which 1. Every node has at most two children (binary). The tree is engrely filled except for the boyom level which is filled from lez to right (complete) Longest path is ceiling(log n) for n nodes

7 Min- Heap: Example Root = Smallest element Next open spot Last filled posigon (not necessarily the last element added)

8 Maintaining the Heap: AddiGon Add element: New element in next open spot. Place new element in next available posigon, then fix it by percolagng up

9 Maintaining the Heap: AddiGon (cont.) AZer first iteragon (swapped with ) 10 PercolaGng up: while new value is less than parent, swap value with parent AZer second iteragon (swapped with ) New value not less than parent à Done

10 Maintaining the Heap: Removal Since each node s value is less than or equal to the values of its children, the root is always the smallest element Thus, the operagons getmin and removemin access and remove the root node, respecgvely Heap removal (removemin): What do we replace the root node with? Hint: How do we maintain the completeness of the tree?

11 Maintaining the Heap: Removal Heap removal (removemin): 1. Replace root with the element in the last filled posigon. Fix heap by percolagng down

12 Maintaining the Heap: Removal removemin : 1. Move element in last filled pos into root. Percolate down Root = Smallest element Last filled posigon

13 Maintaining the Heap: Removal (cont.) Root value removed (16 copied to root and last node removed) 10 PercolaGng down: while greater than smallest child swap with smallest child AZer first iteragon (swapped with )

14 Maintaining the Heap: Removal (cont.) AZer second iteragon (moved up) 1 10 PercolaGng down: while greater than smallest child swap with smallest child AZer third iteragon (moved 1 up) Reached leaf node à Stop percolagng

15 Maintaining the Heap: Removal (cont.) Root = New smallest element New last filled posigon

16 PracGce Insert the following numbers into a min- heap in the order given:, 1,,,, 1, 6,,, 6

17

18 PracGce Remove the minimum value from the min- heap

19

20 Your Turn Complete Worksheet: Heaps PracGce

21 CS61 Data Structures CS 61 Data Structures Heap ImplementaGon

22 Goals Heap RepresentaGon Heap Priority Queue ADT ImplementaGon

23 Dynamic Array RepresentaGon Complete binary tree has structure that is efficiently represented with an array (or dynamic array) a Root b c d e f 0 a 1 b c d e f 6 Children of node i are stored at i + 1 and i + Parent of node i is at floor((i - 1) / ) Why is this a bad idea if tree is not complete?

24 Dynamic Array ImplementaGon (cont.) If the tree is not complete (it is thin, a unbalanced, etc.), the DynArr implementagon will be full of holes b c d e f 0 a 1 b c d 6 e f 1 1 Big gaps where the level is not filled!

25 Heap ImplementaGon: add Things to consider Where does the new value get placed to maintain completeness? How do we guarantee the heap order property? How do we compute a parent index? When do we stop Complete Worksheet # addheap( )

26 Write : addheap void addheap (struct dyarray * heap, TYPE newvalue) { }

27 Heap ImplementaGon: removemin void removeminheap(dynarr *heap){ int last; last = sizedynarr(heap) 1; putdynarr(heap, 0, getdynarr(heap, last)); /* Copy the last element to the first */ removeatdynarr(heap, last); /* Remove last element. */ _adjustheap(heap, last, 0); /* Rebuild heap */ } First element (data[0]) Last element (last) Percolates down from Index 0 to last (not including last which is one beyond the end now!) Last element (last)

28 Heap ImplementaGon: removemin last

29 Heap ImplementaGon: removemin (cont.) last = sizedynarr(heap) 1; putdynarr(heap, 0, getdynarr(heap, last)); /* Copy the last element to the first */ removeatdynarr(heap, last); _adjustheap(heap, last, 0); New root Last element (last)

30 Heap ImplementaGon: _adjustheap _adjustheap(heap, upto, start); _adjustheap(heap, last, 0); Smallest child (min = ) last

31 Heap ImplementaGon: _adjustheap _adjustheap(heap, last, 1); last smallest child

32 Heap ImplementaGon: _adjustheap current is less than smallest child so _adjustheap exits and removemin exits last smallest child

33 Recursive _adjustheap void _adjustheap(struct DynArr *heap, int max, int pos) { int lewidx = pos * + 1; int rghtidx = pos * + ; if (rghtidx < max) { /* Have two children */ /* Get index of smallest child (_minidx). */ /* Compare smallest child to pos. */ /* If necessary, swap and call _adjustheap(max, minidx). */ } else if (lewidx < max) { /* Have only one child. */ /* Compare child to parent. */ /* If necessary, swap */ } /* Else no children, we are at a leaf */ }

34 Useful RouGnes void swap(struct DynArr *arr, int i, int j) { /* Swap elements at indices i and j. */ TYPE tmp = arr- >data[i]; arr- >data[i] = arr- >data[j]; arr- >data[j] = tmp; } int minidx(struct DynArr *arr, int i, int j) { /* Return index of smallest element value. */ if (compare(arr- >data[i], arr- >data[j]) == - 1) return i; return j; }

35 Priority Queues: Performance (ave) SortedVector SortedList Heap add O(n) Binary search Slide data up O(n) Linear search O(log n) Percolate up getmin O(1) get(0) O(1) Returns firstlink val O(1) Get root node removemin O(n) Slide data down O(1): Reverse Order O(1) removefront() O(log n) Percolate down So, which is the best implementagon of a priority queue? (What if wrote a getmin() for AVLTree?)

36 Priority Queues: Performance EvaluaGon Recall that a priority queue s main purpose is rapidly accessing and removing the smallest element! Consider a case where you will insert (and ulgmately remove) n elements: ReverseSortedVector and SortedList: InserGons: n * n = n Removals: n * 1 = n Total Gme: n + n = O(n How do they compare in ) terms of space requirements? Heap: InserGons: n * log n Removals: n * log n Total Gme: n * log n + n * log n = n log n = O(n log n)

37 Your Turn Complete Worksheet # - _adjustheap(.. )

38 CS61 Data Structures CS 61 Data Structures BuildHeap and Heapsort

39 Goals Build a heap from an array of arbitrary values HeapSort algorithm Analysis of HeapSort

40 BuildHeap How do we build a heap from an arbitrary array of values???

41 BuildHeap: Is this a proper heap? Are any of the subtrees guaranteed to be proper heaps?

42 BuildHeap: Leaves are proper heaps First non- leaf at floor(n/) - 1 Size = 11 Size/ 1 =

43 BuildHeap How can we use this informagon to build a heap from a random array? _adjustheap: takes a binary tree, rooted at a node, where all subtrees of that node are proper heaps and percolates down from that node to ensure that it is a proper heap void _adjustheap(struct DynArr *heap,int max, int pos) Adjust up to (not inclusive) Adjust from

44 BuildHeap Algorithm Find the first non- leaf node,i, (going from boyom to top, right to lez) adjust heap from it to max Decrement i and repeat ungl you process the root

45 SimulaGon: BuildHeap 0 1 Size = 6 i=size/ 1 = i= _adjustheap(heap,6,)

46 SimulaGon: BuildHeap 0 1 Size = 6 i=1 i=1 _adjustheap(heap,6,1)

47 SimulaGon: BuildHeap 0 1 Size = 6 i= 0 i=0 _adjustheap(heap,6,0)

48 SimulaGon: BuildHeap 0 1 i=- 1 Done with BuildHeap.now let s sort it!

49 HeapSort BuildHeap and _adjustheap are the keys to an efficient, in- place, sorgng algorithm in- place means that we don t require any extra storage for the algorithm Any ideas??? Hint#1: adjust heap only goes up to max Hint#: we ll produce a reverse sorted array

50 HeapSort 1. BuildHeap turn arbitrary array into a heap. Swap first and last elements. Adjust Heap (from 0 to the last not inclusive!). Repeat - but decrement last each Gme through

51 HeapSort SimulaGon: Sort in Place 0 1 IteraGon 1 i= Swap(v, 0, i) _adjustheap(v, i, 0);

52 HeapSort SimulaGon: Sort in Place 0 1 IteraGon 1 i= Swap(v, 0, i) _adjustheap(v, i, 0);

53 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

54 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

55 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

56 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

57 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

58 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i= Swap(v, 0, i) _adjustheap(v, i, 0);

59 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i=1 Swap(v, 0, i) _adjustheap(v, i, 0);

60 HeapSort SimulaGon: Sort in Place 0 1 IteraGon i=1 Swap(v, 0, i) _adjustheap(v, i, 0);

61 HeapSort SimulaGon: Sort in Place 0 1 i=0 DONE

62 HeapSort Performance Build Heap: n/ calls to _adjustheap = O(n log n) HeapSort: n calls to swap and adjust = O(n log n) Total: O(n log n)

63 Your Turn Worksheet BuildHeap and Heapsort