Download presentation
Presentation is loading. Please wait.
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
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.