CS323: Priority Queues

Emory University Logo Guidelines
-
Priority Queues
Data Structures and Algorithms
Emory University
Jinho D. Choi

-
Priority Queue
2

-
Priority Queue
• Priority queue
2

-
Priority Queue
• Priority queue
- Add: insert a comparable key.
2

-
Priority Queue
• Priority queue
- Remove: ﬁnd and remove the key with the highest priority.
2

-
Priority Queue
• Priority queue
• Application
2

-
Priority Queue
• Priority queue
• Application
- Scheduling.
2

-
Priority Queue
• Priority queue
• Application
- Scheduling.
• Implementation
2

-
Priority Queue
• Priority queue
• Application
- Scheduling.
• Implementation
- Lazy vs. Eager.
2

-
Priority Queue
• Priority queue
• Application
- Scheduling.
• Implementation
- Lazy vs. Eager.
- Heap.
2

-
Abstract Priority Queue
3
public abstract class AbstractPriorityQueue<T extends Comparable<T>>
{
protected Comparator<T> comparator;
public AbstractPriorityQueue(Comparator<T> comparator)
{
this.comparator = comparator;
}
...
}

-
3
{
{
}
...
}
class?

-
3
{
{
}
...
}
class? interface?

-
3
{
{
}
...
}
class? genericinterface?

-
4
{
...
abstract public void add(T key);
abstract protected T removeAux();
abstract public int size();
public boolean isEmpty()
{
return size() == 0;
}
public T remove()
{
if (isEmpty()) throw new NoSuchElementException("No key exists.");
return removeAux();
}
}

-
4
{
...
{
return size() == 0;
}
public T remove()
{
return removeAux();
}
}
abstract
methods

-
4
{
...
{
return size() == 0;
}
public T remove()
{
return removeAux();
}
}
abstract
methods
deﬁned?

-
4
{
...
{
return size() == 0;
}
public T remove()
{
return removeAux();
}
}
abstract
methods
deﬁned?
exception handling

-
Lazy Priority Queue
5

-
Lazy Priority Queue
5
Add: insert each key to the back of the list.

-
Lazy Priority Queue
5
Remove: ﬁnd the key with the priority, and remove it from the list.

-
Lazy Priority Queue
5
public class LazyPriorityQueue<T extends Comparable<T>> 
extends AbstractPriorityQueue<T>
{
private List<T> keys;
public LazyPriorityQueue()
{
this(Comparator.naturalOrder());
}
public LazyPriorityQueue(Comparator<T> comparator)
{
super(comparator);
keys = new ArrayList<>();
}

-
Lazy Priority Queue
5
public class LazyPriorityQueue<T extends Comparable<T>> 
extends AbstractPriorityQueue<T>
{
public LazyPriorityQueue()
{
this(Comparator.naturalOrder());
}
public LazyPriorityQueue(Comparator<T> comparator)
{
super(comparator);
}
calls?

-
Lazy Priority Queue
6
@Override
public int size()
{
return keys.size();
}
@Override
public void add(T key)
{
keys.add(key);
}
@Override
protected T removeAux()
{
T max = Collections.max(keys, comparator);
keys.remove(max);
return max;
}

-
Lazy Priority Queue
6
@Override
public int size()
{
return keys.size();
}
@Override
{
keys.add(key);
}
@Override
{
keys.remove(max);
return max;
}
annotation

-
Lazy Priority Queue
6
@Override
public int size()
{
return keys.size();
}
@Override
{
keys.add(key);
}
@Override
{
keys.remove(max);
return max;
}
annotation
complexity?

-
Lazy Priority Queue
6
@Override
public int size()
{
return keys.size();
}
@Override
{
keys.add(key);
}
@Override
{
keys.remove(max);
return max;
}
annotation
complexity?
built-in method
https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html

-
Lazy Priority Queue
6
@Override
public int size()
{
return keys.size();
}
@Override
{
keys.add(key);
}
@Override
{
keys.remove(max);
return max;
}
annotation
complexity?
complexity?
built-in method

-
Eager Priority Queue
7

-
7
Add: insert each key to the list according to the priority.

-
7
Remove: remove the last key in the list.

-
7
@Override
{
int index = Collections.binarySearch(keys, key, comparator);
if (index < 0) index = -(index + 1);
keys.add(index, key);
}
@Override
{
return keys.remove(keys.size()-1);
}

-
7
@Override
{
}
@Override
{
}

-
7
@Override
{
}
@Override
{
}
complexity?

-
7
@Override
{
}
@Override
{
}
complexity?
complexity?

-
Binary Heap
8

-
Binary Heap
• What is a heap?
8

-
Binary Heap
• What is a heap?
- A tree where the key of each node has a higher or equal priority than
its children.
8

-
Binary Heap
• What is a heap?
its children.
- The tree is guaranteed to be balanced.
8

-
Binary Heap
• What is a heap?
its children.
- What is a binary heap? 
8

-
Binary Heap
• What is a heap?
its children.
• Operations
8

-
Binary Heap
• What is a heap?
its children.
• Operations
- Add: swim.
8

-
Binary Heap
• What is a heap?
its children.
• Operations
- Add: swim.
- Remove: sink.
8

-
Binary Heap
• What is a heap?
its children.
• Operations
- Add: swim.
- Remove: sink.
- Both operations can be done in O(log n).
8

-
Binary Heap
9

-
Binary Heap
9
7 3 2 4 6 1 5Input =

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =
Why?

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =
Index of the parent?
Why?

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =
k/2
Why?

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =
Index of the children?
k/2
Why?

-
Binary Heap
9
7 3 2 4 6 1 5Input =
7
6 5
3 4 1 2
∅ 7 6 5 3 4 1 2list =
Index of the children?
k/2
k*2, k*2 + 1
Why?

-
public class BinaryHeap<T extends Comparable<T>> extends AbstractPriorityQueue<T>
{
private int size;
public BinaryHeap(Comparator<T> comparator)
{
super(comparator);
keys.add(null);
size = 0;
}
@Override
public int size()
{
return size;
}
Binary Heap
10

-
public class BinaryHeap<T extends Comparable<T>> extends AbstractPriorityQueue<T>
{
private int size;
public BinaryHeap(Comparator<T> comparator)
{
super(comparator);
keys.add(null);
size = 0;
}
@Override
public int size()
{
return size;
}
Binary Heap
10
initialize the ﬁrst item as null

-
Binary Heap - Add (Swim)
11
7 3 2 4 6 1 5

-
11
7 3 2 4 6 1 5
Add each key to the end of the list.
Swim until it becomes a heap.

-
11
7 3 2 4 6 1 5
7

-
11
7 3 2 4 6 1 5
7
3

-
11
7 3 2 4 6 1 5
7
3 2

-
11
7 3 2 4 6 1 5
7
3 2
4

-
11
7 3 2 4 6 1 5
7
3 2
4
4
3

-
11
7 3 2 4 6 1 5
7
3 2
4 6
4
3

-
11
7 3 2 4 6 1 5
7
3 2
4 6
4
3
6
4

-
11
7 3 2 4 6 1 5
7
3 2
4 6 1
4
3
6
4

-
11
7 3 2 4 6 1 5
7
3 2
4 6 1 5
4
3
6
4

-
11
7 3 2 4 6 1 5
7
3 2
4 6 1 5
4
3
6
4
5
2

-
11
7 3 2 4 6 1 5
7
3 2
4 6 1 5
4
3
6
4
5
2
Complexity?

-
12
@Override
{
keys.add(key);
swim(++size);
}
private void swim(int k)
{
while (k > 1 && comparator.compare(keys.get(k/2), keys.get(k)) < 0)
{
Collections.swap(keys, k/2, k);
k /= 2;
}
}

-
12
@Override
{
keys.add(key);
swim(++size);
}
private void swim(int k)
{
while (k > 1 && comparator.compare(keys.get(k/2), keys.get(k)) < 0)
{
Collections.swap(keys, k/2, k);
k /= 2;
}
}
parent

-
Binary Heap - Remove (Sink)
13

-
13
Replace the root with the last key in the list.
Sink until it becomes a heap.

-
13
7
6 5
3 4 1 2

-
13
7
6 5
3 4 1
2

-
13
7
6 5
3 4 1
26
2

-
13
7
6 5
3 4 1
26
24
2

-
13
7
6 5
3 4
26
24
2
1

-
13
7
6 5
3 4
26
24
2
15
1

-
14
@Override
{
Collections.swap(keys, 1, size);
T max = keys.remove(size--);
sink(1);
return max;
}
private void sink(int k)
{
for (int i=k*2; i<=size; k=i,i*=2)
{
if (i < size && comparator.compare(keys.get(i), keys.get(i+1)) < 0) i++;
if (comparator.compare(keys.get(k), keys.get(i)) >= 0) break;
Collections.swap(keys, k, i);
}
}

-
14
@Override
{
sink(1);
return max;
}
{
{
}
}
root

-
14
@Override
{
sink(1);
return max;
}
{
{
}
}
root
left child

-
14
@Override
{
sink(1);
return max;
}
{
{
}
}
root
left child
between children

-
Unit Test - Accuracy
15
void testAccuracy(AbstractPriorityQueue<Integer> q, Comparator<Integer> sort)
{
List<Integer> keys = DSUtils.toIntegerList(4,1,3,2,5,6,8,3,4,7,5,9,7);
keys.forEach(key -> q.add(key));
Collections.sort(keys, sort);
keys.forEach(key -> assertEquals(key, q.removeAux()));
}
@Test
public void testAccuracy()
{
testAccuracy(new LazyPriorityQueue<>() , Comparator.reverseOrder());
testAccuracy(new EagerPriorityQueue<>(), Comparator.reverseOrder());
testAccuracy(new BinaryHeap<>() , Comparator.reverseOrder());
testAccuracy(new LazyPriorityQueue<Integer> (Comparator.reverseOrder()), Comparator.naturalOrder());
testAccuracy(new EagerPriorityQueue<Integer>(Comparator.reverseOrder()), Comparator.naturalOrder());
testAccuracy(new BinaryHeap<Integer> (Comparator.reverseOrder()), Comparator.naturalOrder());
}

-
Unit Test - Accuracy
15
void testAccuracy(AbstractPriorityQueue<Integer> q, Comparator<Integer> sort)
{
List<Integer> keys = DSUtils.toIntegerList(4,1,3,2,5,6,8,3,4,7,5,9,7);
keys.forEach(key -> q.add(key));
Collections.sort(keys, sort);
keys.forEach(key -> assertEquals(key, q.removeAux()));
}
unit test
@Test
public void testAccuracy()
{
testAccuracy(new LazyPriorityQueue<>() , Comparator.reverseOrder());
testAccuracy(new EagerPriorityQueue<>(), Comparator.reverseOrder());
testAccuracy(new BinaryHeap<>() , Comparator.reverseOrder());
testAccuracy(new LazyPriorityQueue<Integer> (Comparator.reverseOrder()), Comparator.naturalOrder());
testAccuracy(new EagerPriorityQueue<Integer>(Comparator.reverseOrder()), Comparator.naturalOrder());
testAccuracy(new BinaryHeap<Integer> (Comparator.reverseOrder()), Comparator.naturalOrder());
}

-
Unit Test - Speed
16

-
Unit Test - Speed
• If you want to see if your program runs as fast as it should,
16

-
Unit Test - Speed
- The best way is using a proﬁler (e.g., JProﬁler).
16

-
Unit Test - Speed
- The easiest way is measuring the time between operations.
16

-
Unit Test - Speed
16
<T extends Comparable<T>>long getRuntime(int warm, int iter, AbstractPriorityQueue<T> q)
{
long st, et;
for (int i=0; i<warm; i++)
q.remove();
st = System.currentTimeMillis();
for (int i=0; i<iter; i++)
q.remove();
et = System.currentTimeMillis();
return et - st;
}

-
Unit Test - Speed
16
{
long st, et;
q.remove();
q.remove();
return et - st;
}
warm-up

-
Unit Test - Speed
16
{
long st, et;
q.remove();
q.remove();
return et - st;
}
warm-up
operation

-
Speed Comparison - Add
17
Milliseconds
0
150
300
450
600
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap

-
17
Milliseconds
0
150
300
450
600
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap
O(1)

-
17
Milliseconds
0
150
300
450
600
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap
Both O(log n)?O(1)

-
Speed Comparison - Remove
18
Milliseconds
0
1000
2000
3000
4000
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap

-
18
Milliseconds
0
1000
2000
3000
4000
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap
O(1)

-
18
Milliseconds
0
1000
2000
3000
4000
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap
O(1) O(log n)

-
18
Milliseconds
0
1000
2000
3000
4000
Queue sizes
100 200 300 400 500 600 700 800 900 1000
Lazy Eager Heap
O(n) O(1) O(log n)

-
Agenda
• Exercise
- https://github.com/emory-courses/cs323/wiki/Priority-Queues
• Reading
- https://en.wikipedia.org/wiki/Selection_sort
- https://en.wikipedia.org/wiki/Insertion_sort
- https://en.wikipedia.org/wiki/Heapsort
- https://en.wikipedia.org/wiki/Shellsort
19

CS323: Priority Queues

More Related Content

What's hot (9)

Similar to CS323: Priority Queues (9)

More from Jinho Choi (20)

Recently uploaded (20)

CS323: Priority Queues