Post on 18-Jan-2016
CS221Week 13 - Friday
Last time
What did we talk about last time? Sorting Insertion sort Merge sort Started quicksort
Questions?
Project 4
Assignment 6
Assignment 7
Quicksort
Quicksort
Pros: Best and average case running time of
O(n log n) Very simple implementation In-place Ideal for arrays
Cons: Worst case running time of O(n2) Not stable
Quicksort algorithm
1. Pick a pivot2. Partition the array into a left half
smaller than the pivot and a right half bigger than the pivot
3. Recursively, quicksort the left half4. Recursively quicksort the right half
Partition algorithm
Input: array, index, left, right Set pivot to be array[index] Swap array[index] with array[right] Set index to left For i from left up to right – 1
If array[i] ≤ pivot▪ Swap array[i] with array[index]▪ index++
Swap array[index] with array[right] Return index //so that we know where pivot
is
Quicksort Example
7
45
0
54
37
108
0
7
45
54
37
108
0
7
45
54
37
108
0
7
37
45
54
108
0
7
37
45
54
108
0
7
37
45
54
108
0
7
37
45
54
108
Quicksort issues
Everything comes down to picking the right pivot If you could get the median every time, it would be great
A common choice is the first element in the range as the pivot Gives O(n2) performance if the list is sorted (or reverse
sorted) Why?
Another implementation is to pick a random location Another well-studied approach is to pick three random
locations and take the median of those three An algorithm exists that can find the median in linear
time, but its constant is HUGE
Heaps
Heaps
A maximum heap is a complete binary tree where The left and right children of the root
have key values less than the root The left and right subtrees are also
maximum heaps
We can define minimum heaps similarly
Heap example
10
9 3
0 1
How do you know where to add?
Easy! We look at the location of the new
node in binary Ignore the first 1, then each 0 is for
going left, each 1 is for going right
New node
Location: 6 In binary: 110 Right then left
10
9 3
0 1
Add 15
Oh no! 10
9 3
0 1 15
After an add, bubble up
10
9 3
0 1 15
10
9 15
0 1 3
15
9 10
0 1 3
Only the root can be deleted
10
9 3
0 1
Replace it with the “last” node
9 3
0 1
9 3
0
1
Then, bubble down
9 3
0
1
1 3
0
9
Operations
Heaps only have: Add Remove Largest Get Largest
Which cost: Add: O(log n) Remove Largest: O(log n) Get Largest: O(1)
Heaps are a perfect data structure for a priority queue
Priority queue implementation
Priority queue
A priority queue is an ADT that allows us to insert key values and efficiently retrieve the highest priority one
It has these operations: Insert(key) Put the key into the
priority queue
Max() Get the highest value key Remove Max() Remove the highest value
key
Implementation
It turns out that a heap is a great way to implement a priority queue
Although it's useful to think of a heap as a complete binary tree, almost no one implements them that way
Instead, we can view the heap as an array
Because it's a complete binary tree, there will be no empty spots in the array
Array implementation of priority queue
public class PriorityQueue {
private int[] keys = new int[10];
private int size = 0;…
}
Array view
Illustrated:
The left child of element i is at 2i + 1 The right child of element i is at 2i + 2
10
9 3
0 1
10 9 3 0 1
0 1 2 3 4
Insert
public void insert(int key)
Always put the key at the end of the array (resizing if needed)
The value will often need to be bubbled up, using the following helper method
private void bubbleUp(int index)
Max
public int max()
Find the maximum value in the priority queue
Hint: this method is really easy
Remove Max
public int removeMax()
Store the value at the top of the heap (array index 0)
Replace it with the last legal value in the array
This value will generally need to be bubbled down, using the following helper method
Bubbling down is harder than bubbling up, because you might have two legal children!
private void bubbleDown(int index)
Heap Sort
Heap sort
Pros: Best, worst, and average case running
time ofO(n log n)
In-place Good for arrays
Cons: Not adaptive Not stable
Heap sort algorithm
Make the array have the heap property:1. Let i be the index of the parent of the last two
nodes2. Bubble the value at index i down if needed3. Decrement i4. If i is not less than zero, go to Step 2
1. Let pos be the index of the last element in the array
2. Swap index 0 with index pos3. Bubble down index 04. Decrement pos5. If pos is greater than zero, go to Step 2
Heap sort heapify example
7
45
0
54
37
108
51
7
45
108
54
37
0
51
7
54
108
45
37
0
51
108
54
51
45
37
0
7
Heap sort extraction example
108
54
51
45
37
0
7
51
45
0
7
37
54
108
45
37
0
7
51
54
108
37
7
0
45
51
54
108
7
0
37
45
51
54
108
0
7
37
45
51
54
108
54
45
51
7
37
0
108
Heap sort implementation
Heap sort is a clever algorithm that uses part of the array to store the heap and the rest to store the (growing) sorted array
Even though a priority queue uses both bubble up and bubble down methods to manage the heap, heap sort only needs bubble down
You don't need bubble up because nothing is added to the heap, only removed
Heapify Implementation
Upcoming
Next time…
Counting sort Radix sort Start tries
Reminders
Work on Project 4Finish Assignment 6
Due today by midnight!Start on Assignment 7
Due when you return from Thanksgiving
Read sections 5.1 and 5.2 Office hours are canceled today
because of a visiting faculty candidate