CS221Week 13 - Wednesday

Last time

What did we talk about last time? NP-completeness

Questions?

Project 4

Assignment 6

SortingStudent Lecture

What do we want from sorting?

Characteristics of a sort Running time

Best case Worst case Average case

Stable Will elements with the same value get reordered?

Adaptive Will a mostly sorted list take less time to sort?

In-place Can we perform the sort without additional memory?

Simplicity of implementation Relates to the constant hidden by Big Oh

Online Can sort as numbers arrive

Insertion Sort

Insertion sort

Pros: Best case running time of O(n) Stable Adaptive In-place Simple implementation (one of the fastest

sorts for 10 elements or fewer!) Online

Cons: Worst case running time of O(n2)

Insertion sort algorithm

We do n rounds For round i, assume that the elements 0

through i – 1 are sorted Take element i and move it up the list of

already sorted elements until you find the spot where it fits

Insertion sort example

7

45

0

54

37108

51

7

45

0

54

37108

51

0

7

45

54

37108

51

0

7

45

54

37108

51

0

7

37

45

54108

51

0

7

37

45

54108

51

0

7

37

45

51

54108

Insertion Sort Implementation

Merge Sort

Merge sort Pros:

Best, worst, and average case running time ofO(n log n)

Stable Ideal for linked lists

Cons: Not adaptive Not in-place▪ O(n) additional space needed for an array▪ O(log n) additional space needed for linked lists

Merge sort algorithm

Take a list of numbers, and divide it in half, then, recursively: Merge sort each half After each half has been sorted, merge

them together in order

Merge sort example7

45

0

45

0

0

45

0

7

45

54

37108

37

108

37108

37

54108

7

45

0

54

37108

0

7

37

45

54108

7

45

0

54

37108

Merge Sort Implementation

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

37108

0

7

45

54

37108

0

7

45

54

37108

0

7

37

45

54108

0

7

37

45

54108

0

7

37

45

54108

0

7

37

45

54108

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)

Upcoming

Next time…

Heapsort TimSort Counting sort Radix sort

Reminders

Work on Project 4Work on Assignment 6

Due on Friday Read sections 2.4 and 5.1