Algorithms - Week 4-0 Priority Queues_queues and priority queues are data structures whi-CSDN博客

本文链接：https://blog.csdn.net/novostary/article/details/48489421

APIs and Elementary Implementations

Collections. Insert and delete item.

Stack, Queue, Randomized queue, Priority queue.

Priority queue applications

Event-driven simulation. [customers in a line, colliding particles]
Numerical computation. [reducing roundoff error]
Data compression. [Huffman codes]
Graph searching. [Dijkstra’s algorithm, Prim’s algorithm]
Number theory. [sum of powers]
Artificial intelligence. [A* search]
Statistics. [maintain largest M values in a sequence]
Operating systems. [load balancing, interrupt handling]
Discrete optimization. [bin packing, scheduling]
Spam filtering. [Bayesian spam filter]

Elementary PQ(MN), binary heap(NlogM)

insert, delmax, max

unordered array implementation

ordered array

Challenge. Implement all operations efficiently.

Binary Heaps

Binary tree. Empty or node with links to left and right binary trees.

Complete tree. Perfectly balanced, except for bottom level.

Binary heap. Array representation of a heap-ordered complete binary tree.

Heap-ordered binary tree.

keys in nodes.
Parent’s key no smaller than children’s keys.

Array representation.

Indices start at 1.
Take nodes in level order.
No explicit links needed!

Proposition. Largest key is a[1], which is root of binary tree.

Proposition. Can use array indices to move through tree.

parent of node is at k/2.
Children of node at k are at 2k and 2k+1

Peter principle. Node promoted to level of incompetence.

private void swim(int k)
{
    while (k > 1 && less(k/2, k))
    {
        exch(k, k/2);
        k = k/2;
    }
}

Insert. Add node at end, then swim it up.

public void insert(Key x)
{
    pq[++N] = x;
    swim(N);
}

Demotion in a heap

Scenario. Parent’s key becomes smaller than one (or both) of its children’s.

To eliminate the violation:

Exchange key in parent with key in larger child.
Repeat until heap order restored.

private void sink(int k)
{
while (2*k <= N)
{
int j = 2*k;
if (j < N && less(j, j+1)) j++;
if (!less(k, j)) break;
exch(k, j);
k = j;
}
}

Power struggle. Better subordinate promoted.

Delete the maximum in a heap

Delete max. Exchange root with node at end, then sink it down.

public Key delMax()
{
    Key max = pq[1];
    exch(1, N--);
    sink(1);
    pq[N+1] = null;
    return max;
}

public class MaxPQ<Key extends Comparable<Key>>
{
    private Key[] pq;
    private int N;
    public MaxPQ(int capacity)
    { 
        pq = (Key[]) new Comparable[capacity+1]; // ???
    }
    public boolean isEmpty()
    { return N == 0; }
    public void insert(Key key)
    public Key delMax()
    { /* see previous code */ }
    private void swim(int k)
    private void sink(int k)
    { /* see previous code */ }
    private boolean less(int i, int j)
    { 
        return pq[i].compareTo(pq[j]) < 0; 
    }
    private void exch(int i, int j)
    { 
        Key t = pq[i]; pq[i] = pq[j]; pq[j] = t; 
    }
}

d-ary heap

Fibonacci

Binary heap considerations

Immutability of keys.

Assumption: client does not change keys while they’re on the PQ.
Best practice: use immutable keys.

Underflow and overflow.

Underflow: throw exception if deteting from empty PQ.
Overflow: add no-arg constructor and use resizing array.

Minimum-oriented priority queue.

Replace less() with greater().
Implement greater().

Other operations.

Remove an arbitrary item.
Change the priority of an item.

Immutability: implementing in Java

Data type. Set of values and operations on those values.
Imumutable data type. Can’t change the data type value once created.

Immutable. String, Integer, Double, Color, Vector, Transaction, Point2D. // ???
Mutable. StringBuilder, Stack, Counter, Java array.

public final class Vector { // can't override instance methods
    private final int N;
    private final double[] data; // all instance variables private and final
    public Vector(double[] data) { // defensive copy of mutable instance variables
        this.N = data.length;
        this.data = new double[N];
        for (int i = 0; i < N; i++)
        this.data[i] = data[i];
    }
    … // instance methods don't change instance variables
}

Advantages.

Simplifies debugging.
Safer in presence of hostile code.
Simplifies concurrent programming.
Safe to use as key in priority queue or symbol table.

Disadvantage. Must create new object for each data type value.

Heapsort

Basic plan for in-place sort.

Create max-heap with all N keys.
Repeatedly remove the maximum key.

Heap construction. Build max heap using bottom-up method.

for (int k = N/2; k >= 1; k--)
    sink(a, k, N);

Sortdown. Repeatedlly delte the largest remaining item.

while (N > 1)
{
    exch(a, 1, N--);
    sink(a, 1, N);
}

public class Heap
{
    public static void sort(Comparable[] a)
    {
        int N = a.length;
        for (int k = N/2; k >= 1; k--)
            sink(a, k, N);
        while (N > 1)
        {
            exch(a, 1, N);
            sink(a, 1, --N);
        }
    }
    private static void sink(Comparable[] a, int k, int N)
    { /* as before */ }
    private static boolean less(Comparable[] a, int i, int j)
    { /* as before */ }
    private static void exch(Comparable[] a, int i, int j)
    { /* as before */ }
}

but convert from 1-based indexing to 0-base indexing

Heapsort: mathematical analysis

Proposition. Heap construction uses ≤ 2 N compares and exchanges.
Proposition. Heapsort uses ≤ 2 N lg N compares and exchanges

Significance. In-place sorting algorithm with N log N worst-case.

Mergesort: no, linear extra space. // in-place merge possible, not practical
Quicksort: no, quadratic time in worst case. // N log N worst-case quicksort possible, not practical
Heapsort: yes!

Bottom line. Heapsort is optimal for both time and space, but: