普林斯顿·算法·PART I：PRIORITY QUEUES

1.Priority queue

以某种方式排序，总是处理最优的。

2.Binary heaps

root 为最大值
2.1 回溯—>插入元素
回溯：

插入元素：

2.2下沉——>删除元素
下沉：

删除元素：

整体代码与性能：

3.HeapSort

堆排序

4.Event-driven simulation

目标：根据弹性膨胀原理，模拟N个移动的例子运动状态变化。
模型：

• 运动的粒子通过弹性相互作用与墙壁碰撞或粒子相互碰撞。
• 每个粒子有已知的位置、速度、重量和半径。
• 没有其他外加力。

1. Time-driven simulation
   
   
   2.Event-driven simulation

粒子与墙撞击的参数更新：

粒子相互碰撞过程的参数更新：

代码框架：

Interview Questions: Priority Queues

1. 维护两个堆，一个大顶堆maxHeap和一个小顶堆minHeap，使其满足以下条件：

maxHeap.size == minHeap.size 或者 maxHeap.size == minHeap.size + 1

minHeap中的任意元素都比maxHeap中的任意元素大

/*
abstract class Heap {
    protected int size;
    protected int[] heap;

    public Heap() {
        heap = new int[2];
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void insert(int n) {
        if (size == heap.length) {
            resize(2 * heap.length);
        }
        heap[size++] = n;
        swim(size - 1);
    }

    public int peek() {
        return heap[0];
    }

    public int remove() {
        int temp = heap[0];
        exch(0, --size);
        if (size > 0 && size == heap.length / 4) {
            resize(heap.length / 2);
        }
        sink(0);
        return temp;
    }

    abstract boolean compare(int i, int j);

    protected void swim(int k) {
        while (k > 0 && compare(k / 2, k)) {
            exch(k / 2, k);
            k /= 2;
        }
    }

    protected void sink(int k) {
        while (2 * k <= size - 1) {
            int j = 2 * k;
            if (j < size - 1 && compare(j, j + 1)) {
                j++;
            }
            if (!compare(k, j)) {
                break;
            }
            exch(k, j);
            k = j;
        }
    }

    protected void resize(int capacity) {
        int[] temp = new int[capacity];
        for (int i = 0; i < heap.length; i++) {
            temp[i] = heap[i];
        }
        heap = temp;
    }

    protected void exch(int i, int j) {
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

class MaxHeap extends Heap {
    @Override
    boolean compare(int i, int j) {
        return heap[i] < heap[j];
    }
}

class MinHeap extends Heap {
    @Override
    boolean compare(int i, int j) {
        return heap[i] > heap[j];
    }
}
*/

public class DynamicMedian {
   
    MaxHeap maxHeap;
    MinHeap minHeap;

    public DynamicMedian() {
   
        maxHeap = new MaxHeap();
        minHeap = new MinHeap();
    }


    public void insert(int n) {
   
        // 依照大小切分元素
        if (maxHeap.isEmpty()) {
   
            maxHeap.insert(n);
        } else {
   
            if (n > maxHeap.peek()) {
   
                minHeap.insert(n);
            } else {
   
                maxHeap.insert(n);
            }
        }
        // 使大小两堆的个数满足要求
        if (maxHeap.size + 1 == minHeap.size) {
   
            maxHeap.insert(minHeap.remove());
        }
        if (maxHeap.size == minHeap.size + 2) {
   
            minHeap.insert(maxHeap.remove());
        }
    }

    public int findMedian() {
   
        return maxHeap.peek();
    }

    public int removeMedian() {
   
        return maxHeap.remove();
    }
}

2.删除随机元素的方法：将随机元素与末尾元素交换，使size减1，并从随机位置开始执行一次sink()。

import java.util.Random;

public class RandomizedPQ {
   
    private int[] pq;
    private int size;
    Random random;

    public RandomizedPQ(int[] pq) {
   
        this.pq = pq;
        random = new Random();
    }

    public boolean isEmpty() {
   
        return size == 0;
    }

    public void insert(int n) {
   
        if (size == pq.length) {
   
            resize(2 * size);
        }
        pq[size++] = n;
        swim(size - 1);
    }

    public int sample() {
   
        int r = random.nextInt(size);
        return pq[r];
    }

    public int