1. CS420 lecture five Priority Queues, Sorting wim bohm cs csu

2. Heaps Heap: array representation of a complete binary tree – every level is completely filled except the bottom level: filled from left to right Can compute the index of parent and children – parent(i) = floor(i/2) left(i)= 2i index(i)=2i+1 (for 1 based arrays) Heap property: A[parent(i)] >= A[i] 16 10 9 3 1 4 2 7 8 14 16 14 10 8 7 9 3 2 4 1

3. Heapify To create a heap at i, assuming left(i) and right(i) are heaps, bubble A[i] down: swap with max child until heap property holds heapify(A,i){ L=left(i); R=right(i); if L A[i] max=L else max = i; if R A[max] max =R; if max != i { swap(A,i,max); heapify(A.max) }

4. Building a heap heapify performs at most lg n swaps building a heap out of an array: – The leaves are all heaps – heapify backwards starting at last internal node buildheap(A){ for i = floor(n/2) downto 1 heapify(A,i) }

5. Complexity buildheap Suggestions?...

6. Complexity buildheap initial thought O(nlgn), but half of the heaps are height 1 quarter are height 2 only one is height log n It turns out that O(nlgn) is not tight!

7. complexity buildheap height 0 1 2 3 max #swaps 0 = 2 1 -2 1 = 2 2 -3 2*1+2 = 4 = 2 3 -4 2*4+3 = 11 = 2 4 -5

8. complexity buildheap height 0 1 2 3 max #swaps 0 = 2 1 -2 1 = 2 2 -3 2*1+2 = 4 = 2 3 -4 2*4+3 = 11 = 2 4 -5 Conjecture: height = h max #swaps = 2 h+1 -(h+2) Proof: induction height = (h+1) max #swaps: 2*(2 h+1 -(h+2))+(h+1) = 2 h+2 -2h-4+h+1 = 2 h+2 -(h+3) = 2 (h+1)+1 -((h+1)+2) n nodes  O(n) swaps

9. Cormen et.al. complexity buildheap

10. Differentiation trick (Cormen et.al. Appendix A)

11. Heapsort heapsort(A){ buildheap(A); for i = n downto 2{ swap(A,1,i); n=n-1; heapify(A,1); }

12. Complexity heapsort buildheap: O(n) swap/heapify loop: O(nlgn) space: in place: n – less space than merge sort

13. 1 4 2 7 8 14 1 2 7 4 8 8 2 1 4 7 8 7 1 2 4 8 7 4 1 2 8 7 4 2 1

14. Priority Queues heaps are used in priority queues – each value associated with a key – max priority queue S (as in heapsort) has operations that maintain the heap property of S insert(S,x) max(S) returning max element Extract-max(S) extracting and returning max element increase key(S,x,k) increasing the key value of x

15. Extract max: O(log n) Extract-max(S){ // pre:N>0 max=S[1]; S[1]=S[N]; N=N-1; heapify(S) } O(log N)

16. Increase key: O(log n) Increase-key(S,i,k){ //pre: k>S[i] A[i]=k; // bubble up while(i>1 and S[parent(i)]<S[i]){ swap(S,i,parent(i)); i = parent(i) }

17. Insert O(log n) Insert(S,x) – put x at end of S – bubble x up like in Increase-key

18. Decrease-key How would decrease key work? What would be its complexity?

19. Quicksort Quicksort has worst case complexity?

20. Quicksort Quicksort has worst case complexity O(n 2 ) So why do we care about Quicksort?

21. Quicksort Quicksort has worst case complexity O(n 2 ) So why do we care about Quicksort? – Because it is very fast in practice Average complexity: O(nlgn) Low multiplicative constants Sequential array access In place Often faster than MergeSort and HeapSort

22. Partition: O(n) Partition(A,p,r){ // partition A[p..r] in-place in two sub arrays: low and hi // all elements in low < all elements in hi // return index of last element of low x=A[p]; i=p-1; j=r+1; while true repeat j=j-1 until A[j]<=x repeat i=i+1 until A[i]>x if i<j swap(A,i,j) else return j }

23. QuickSort Quicksort(A,p,r){ if p<r { q=Partition(A,p,r) Quicksort(A,p,q) Quicksort(A,q+1,r) } Worst case complexity: when one partition is size 1: T(n)=T(n-1)+n=T(n-2)+(n-1)+n=T(n-3)+(n-2)+(n-1)+n= = O(n 2 )

24. Quicksort average case complexity Assume a uniform distribution: each partition index has equal probability 1/n. Thus

25. Quicksort average case complexity We are summing all Ts up (T(q)) and down (T(N-q)), both are the same sums so

26. Quicksort average case complexity multiply both sides by n substitute n-1 for n

27. Quicksort average case complexity subtract (2)-(3)

28. Quicksort average case complexity Which technique that we have learned can help us here?

29. Quicksort average case complexity repeated substitution!!

30. Quicksort average case complexity