数据结构----优先队列&二叉堆&最大堆

1. 普通队列和优先队列区别

1. 普通队列：先入先出，后进后出；
2. 优先队列：出队顺序和入队顺序无法；主要取决于“优先级”。

2. 二叉堆

1. 二叉堆性质
   1. 底层是一棵二叉完全树(多余的数据，都要放在左子树这边，保证右子树为空。)
      
   2. 堆中某个节点的值，总是不大于其父节点的值，这样根节点就是值最大的节点；因此，也称为最大堆；最小堆则是：父节点的值总是小于子节点的值，因此，根节点是最小的值节点。

3. 最大堆源码

/**
 * 使用动态数组实现最大堆
 */
public class MaxHeap<T extends Comparable<T>> {
    private ArrayList<T> data;

    public MaxHeap() {
        data = new ArrayList<>();
    }

    public MaxHeap(int capacity) {
        data = new ArrayList<>(capacity);
    }

    public int getSize() {
        return data.size();
    }

    public boolean isEmpty() {
        return data.isEmpty();
    }

    // 查询最大节点值
    public T findMax() {
        if (getSize() == 0) {
            throw new IllegalArgumentException("This array is empty!");
        }

        return data.get(0);
    }

    // 取出堆中最大元素
    public T extractMax() {
        T max = findMax();

        // 1. 交换最大元素和最后一个元素
        swap(0, getSize() - 1);

        // 2. 交换之后, 最大的节点就在数组最末尾位置
        data.remove(getSize() - 1);

        // 3. 下沉元素
        siftDown(0);

        return max;
    }

    /**
     * 下沉: 因为插入的元素, 可能比孩子节点值更小, 需要调整元素位置, 保证完全二叉树的规则性.
     * @param k：需要下沉的元素索引
     */
    private void siftDown(int k) {
        // 完全二叉树保证了有右孩子, 就一定存在左孩子.
        while (leftChild(k) < getSize()) {
            int leftChild = leftChild(k);
            int rightChild = rightChild(k);

            // data[leftChild]存储的就是leftChild和rightChild中的最大值
            if (rightChild < getSize() && data.get(rightChild).compareTo(data.get(leftChild)) >= 0) {
                leftChild = rightChild(k);
            }

            // 若k以及比子节点大, 则不需要继续下沉
            if (data.get(k).compareTo(data.get(leftChild)) >= 0) {
                break;
            }

            swap(k, leftChild);
            k = leftChild;
        }
    }

    public void add(T data) {
        this.data.add(data);
        siftUp(this.data.size() - 1);
    }

    /**
     * 上浮: 因为插入的元素, 可能比父节点值更大, 需要调整元素位置, 保证完全二叉树的规则性.
     * @param k: 需要上浮的索引.
     */
    private void siftUp(int k) {
        // 比较k对应的值和它对应的父节点值大小;
        // 若当前节点值大于父节点值时, 则两者进行交换：保证完全二叉树的规则正确.
        while (k > 0 && data.get(k).compareTo(data.get(parent(k))) > 0) {
            swap(k, parent(k));
            k = parent(k);
        }
    }

    private void swap(int i, int j) {
        if (i < 0 || j >= getSize() || j < 0 || i >= getSize()) {
            throw new IllegalArgumentException("Index is illegal.");
        }

        T temp = data.get(i);
        data.set(i, data.get(j));
        data.set(j, temp);
    }

    /**
     * 返回此索引对应在完全二叉树中, 父节点所在的索引.
     *
     * @param index: 子节点索引.
     * @return : 父节点索引
     */
    private int parent(int index) {
        if (index <= 0) {
            throw new IllegalArgumentException(index + " haven't parent!");
        }

        return (index - 1) / 2;
    }

    /**
     * 返回此索引对应在完全二叉树中, 左孩子节点所在的索引.
     *
     * @param index: 父节点索引.
     * @return : 左孩子节点索引
     */
    private int leftChild(int index) {
        return index * 2 + 1;
    }

    /**
     * 返回此索引对应在完全二叉树中, 右孩子节点所在的索引.
     *
     * @param index: 父节点索引.
     * @return : 右孩子节点索引
     */
    private int rightChild(int index) {
        return index * 2 + 2;
    }
}

4. 使用最大堆实现优先队列

/**
 * 使用最大堆实现优先队列.
 */
public class PriorityQueue<T extends Comparable<T>> implements Queue<T> {
    private MaxHeap<T> maxHeap;

    public PriorityQueue() {
        maxHeap = new MaxHeap<>();
    }

    @Override
    public int getSize() {
        return maxHeap.getSize();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }

    @Override
    public void enqueue(T element) {
        maxHeap.add(element);
    }

    @Override
    public T dequeue() {
        return maxHeap.extractMax();
    }

    @Override
    public T getFront() {
        return maxHeap.findMax();
    }
}