每日一省————使用二叉堆实现优先队列

今天，本人主要想复习优先队列这种数据结构。虽然标题号称“每日一省“，但是工作的人身不由己，已经很多天没有更新了。哈哈，废话不多说，直接进入正题吧。

1 优先队列的概念：

优先队列是一种抽象的数据结构，队列中的每个元素都有一个优先级值。优先级值用来表示该元素的出对的先后次序。
优先队列是至少允许插入操作和删除最小（或者最大）元素这两种操作的数据结构。通常，优先队列通过二叉堆来实现。

2 二叉堆的概念：

堆是一棵被完全填满的二叉树，底层例外，底层上的元素从左到右依次填入。如果使用数组表示二叉堆，那么对于数组上的任意位置i上的元素，其左子元素索引是2i，右子元素的索引是（2i +1），其父节点索引是[i/2]。
堆的性质，在堆中，每个元素都要保证大于等于另两个特定位置的元素。所以，在堆有序的二叉树中，每个节点又都小于等于它的父节点。所以，根节点是堆有序的二叉树中的最大节点。
当然，对的性质也可以反过来，也即：每个元素都要保证小于等于另两个特定位置的元素。所以，在堆有序的二叉树中，每个节点又都大于等于它的父节点。所以，根节点是堆有序的二叉树中的最小节点。

3 使用二叉堆实现的优先队列的代码示例

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MaxFirstQueue<T> implements Iterable<T> {

    private T[] queue; // 本列子中优先队列的底层实现是二叉堆，而二叉堆又用数组来表示
    private int size = 0; // 表示队列中的元素个数,注意不是表示数组的容量
    private Comparator<T> comparator; // 可选的比较器，可以作为该类的构造函数参数传入

    public MaxFirstQueue(int max) {
        queue = (T[]) new Comparable[max + 1];
    }

    public MaxFirstQueue() {
        this(1);
    }

    public MaxFirstQueue(int initCapacity, Comparator<T> comparator) {
        this.comparator = comparator;
        queue = (T[]) new Object[initCapacity + 1];
        size = 0;
    }

    public MaxFirstQueue(Comparator<T> comparator) {
        this(1, comparator);
    }

    public MaxFirstQueue(T[] values) {
        size = values.length;
        queue = (T[]) new Object[values.length + 1];
        for (int i = 0; i < size; i++) {
            // 用数组表示二叉堆，数组索引为0的位置不存放元素，该位置元素值永远为空
            queue[i + 1] = values[i];
        }
        for (int k = size / 2; k >= 1; k--) {
            sinkDown(k);
        }
        assert isValidHeap();
    }

    public int size() {
        return size;
    }

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

    /*
     * 判断数组queue中的所有元素构成的二叉堆是否满足二叉堆的基本性质，也即父节点元素最大， 然后每个子节点比其更下面的子节点大
     */
    private boolean isValidHeap() {
        return isValidSubHeap(1);
    }

    /*
     * 判断以queue[k]位置为元素的子堆是否满足二叉堆的基本性质:也即父节点（父节点为queue[k]）元素最大，
     * 然后每个子节点比其更下面的子节点大
     */
    private boolean isValidSubHeap(int k) {
        if (k > size) {
            return true;
        }
        int left = 2 * k, right = 2 * k + 1;
        if (left <= size && less(k, left)) {
            return false;
        }
        if (right <= size && less(k, right)) {
            return false;
        }
        return isValidSubHeap(left) && isValidSubHeap(right);
    }

    /**
     * 取出最大值
     */
    public T max() {
        if (isEmpty()) {
            throw new NoSuchElementException("每次可以取出最大元素的优先队列已经为空，没有任何元素存储其中了");
        }
        return queue[1];
    }

    /**
     * 插入元素
     */
    public void add(T value) {
        if (size >= queue.length - 1) {
            resize(2 * queue.length);
        }
        queue[++size] = value;
        swimUP(size);
        assert isValidHeap();
    }

    /**
     * 删除一个元素后，实际是把删除的元素的放到了索引为size的位置（再把该位置元素值设为null）， 该位置已经不能算做是二叉堆的一部分了。
     * 二叉堆的大小变为size--
     * 
     * 下面的三行代码可以合写为exchange(1, size--), queue[size + 1] = null，这三行代码如下：
     * exchange(1, size); queue[size] = null; size--;
     */
    public T deleteMax() {
        if (isEmpty()) {
            throw new NoSuchElementException("每次可以取出最大元素的优先队列已经为空，没有任何元素存储其中了");
        }
        T value = queue[1];
        exchange(1, size);
        queue[size] = null;
        size--;
        sinkDown(1);
        if ((size > 0) && (size == (queue.length - 1) / 4)) {
            resize(queue.length / 2);
        }
        assert isValidHeap();
        return value;
    }

    /*
     * 调整底层数组的大小：具体做法是创建指定大小的临时数组，然后把queue中的元素移动到这个临时数组的相应位置，
     * 最后再将这个临时数组设置为优先队列的底层实现。
     */
    private void resize(int capacity) {
        assert capacity > size;
        T[] temp = (T[]) new Object[capacity];
        for (int i = 1; i <= size; i++) {
            temp[i] = queue[i];
        }
        queue = temp;
    }

    private boolean less(int i, int j) {
        if (comparator == null) {
            return ((Comparable<T>) queue[i]).compareTo(queue[j]) < 0;
        } else {
            return comparator.compare(queue[i], queue[j]) < 0;
        }
    }

    private void exchange(int i, int j) {
        T temp = queue[i];
        queue[i] = queue[j];
        queue[j] = temp;
    }

    /*
     * 将元素值大于父节点的子节点与父节点交换位置，保持堆有序。交换位置后，原来的子节点可能仍然比 更上层的父节点大，
     * 所以整个过程需要递归进行。这样一来，原来的子节点 有可能升级为层级更高的父节点，类似于一个物体从湖底往上浮直到达到其重力与浮力相平衡的过程。
     */
    private void swimUP(int k) {
        while (k > 1 && less(k / 2, k)) {
            exchange(k, k / 2);
            k = k / 2;
        }
    }

    /*
     * 将元素值小于子节点的父节点与子节点交换位置，交换位置后， 原来的父节点仍然有可能比其下面的子节点小，
     * 所以还需要继续进行类相同的操作，以便保持堆的有序性。所以整个过程递归进行。
     * 这类似于一个物体从湖面下沉到距离湖底的某个位置，直到达到其重力与浮力相平衡为止。
     */
    private void sinkDown(int k) {
        while (2 * k <= size) {
            int j = 2 * k;
            if (j < size && less(j, j + 1)) {
                j++;
            }
            if (!less(k, j)) {
                break;
            }
            exchange(k, j);
            k = j;
        }
    }

    @Override
    public Iterator<T> iterator() {
        return new MaxFirstQueueIterator();
    }

    /**
     * 用于遍历优先队列中元素的迭代器的具体实现：
     */
    private class MaxFirstQueueIterator implements Iterator<T> {

        /*
         * 相当于被迭代的优先队列的一个副本，遍历优先队列中的元素其实遍历的是其副本，
         * 所以，在多线程环境下，并发的增加、删除、遍历元素可能会导致数据错乱。
         */
        private MaxFirstQueue<T> copy;

        public MaxFirstQueueIterator() {
            if (comparator == null) {
                copy = new MaxFirstQueue<T>(size());
            } else {
                copy = new MaxFirstQueue<T>(size(), comparator);
            }
            for (int i = 1; i <= size; i++)
                copy.add(queue[i]);
        }

        public boolean hasNext() {
            return !copy.isEmpty();
        }

        public void remove() {
            throw new UnsupportedOperationException("迭代器不支持移除操作");
        }

        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return copy.deleteMax();
        }
    }

    /**
     * 主方法：包含有测试代码
     */
    public static void main(String[] args) {
        MaxFirstQueue<String> pq = new MaxFirstQueue<String>();
        pq.add("S");
        pq.add("T");
        System.out.println("====================================================");
        for (String e : pq) {
            System.out.println(e);
        }
        pq.add("C");
        pq.add("A");
        pq.add("M");
        pq.add("B");
        System.out.println("====================================================");
        for (String e : pq) {
            System.out.println(e);
        }
        System.out.println("====================================================");
        Iterator<String> iterator = pq.iterator();
        iterator.forEachRemaining(t -> System.out.print("-" + t + "-"));
        System.out.println();
        System.out.println("====================================================");
        try {
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
            System.out.println(pq.deleteMax());
        } catch (Exception e) {
            System.out.println("队列为空，大小为" + pq.size);
        }

        pq.add("C");
        pq.add("A");
        pq.add("M");
        pq.add("B");
        System.out.println("队列大小为" + pq.size);

    }

}