最大、最小优先队列的Java实现

一.最大优先队列

1.概念
普通的队列是一种先进先出（尾插头取）的数据结构，元素在队列尾追加，而从队列头删除。
在某些情况下，我们可能需要找出队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下计算机的任务都是有优先级的，我们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。

普通的队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就可以使用一种特殊的队列来完成这种需求，优先队列，需要基于堆的思想来实现。
由堆的特性，其最大值在根节点处，每次将根节点取出，就相当于是获取了优先级最大的数。
最大优先队列的实现代码与堆的实现代码基本一致，底层同样是使用了数组。重点是理解swim sink delMax方法的逻辑即可。
堆的Java实现

优先队列按照其作用不同，可以分为以下两种：
最大优先队列：可以获取并删除队列中最大的值
最小优先队列：可以获取并删除队列中最小的值

2.实现

public class MaxPriorityQueue<T extends Comparable> { //最大优先队列
    private T[] items; //优先队列基于堆的结构来实现，所以也用数组
    private int N;

    public MaxPriorityQueue(int capacity) {
        this.N = 0;
        this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
    }


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

    private boolean more(int i, int j) {
        return (items[i].compareTo(items[j]) > 0);
    }

    public void insert(T t) {
        items[++N] = t; //使用++N能废弃掉0索引；新加入的元素索引为N
        swim(N); //对索引N的元素使用上浮方法使其有序
    }

    public T delMax() {
        T max = items[1]; //仅记录要删除的最大元素
        swap(1, N);// 将最大元素和索引N处元素交换
        items[N] = null; //删除最大元素
        N--;
        sink(1);  // 通过sink方法让堆变得有序
        return max;
    }

    private void swim(int k) { //上浮，和父节点比较！
        while (k > 1) { //如果k已经到了根节点，则不再需要循环
            if (more(k, k / 2)) {  //如果当前k处结点大于其父结点，则交换
                swap(k, k / 2);
                k = k / 2;
            } else {   //如果当前k处结点小于其父结点，则跳出循环
                break;
            }
        }
    }

    private void sink(int k) { //下沉，和子节点的较大值比较！
        int max;
        while (2 * k <= N) { //k存在左子节点 ，若不存在左子结点2k，也不会存在右子节点2k+1 了！
            if (2 * k + 1 <= N) { //且存在右子节点
                //找出左右子节点的最大
                if (more(2 * k, 2 * k + 1)) { //如果左大于右
                    max = 2 * k;
                } else {
                    max = 2 * k + 1;
                }

            } else { //只有左子结点
                max = 2 * k;
            }

            //比较当前k结点和max
            if (!more(k, max)) {
                swap(k, max);//k小于子节点中最大，则交换
                k = max;
            } else {
                break;
            }
        }
    }


    public int size() {
        return N;
    }


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


    public static void main(String[] args) {
        MaxPriorityQueue<String> p = new MaxPriorityQueue<>(20);
        p.insert("A");
        p.insert("B");
        p.insert("C");
        p.insert("D");
        p.insert("E");
        p.insert("F");
        p.insert("G");

        while (!p.isEmpty()) {
            String s = p.delMax();
            System.out.print("删除当前最大："+s + "\n");
        }
    }
}

测试部分中，每一轮循环输出当前优先级队列中的最大值，输出结果：

删除当前最大：G
删除当前最大：F
删除当前最大：E
删除当前最大：D
删除当前最大：C
删除当前最大：B
删除当前最大：A

二.最小优先队列
最小优先队列的实现逻辑和最大优先队列的基本一样。只是将more换成了less
前面学习堆的时候，堆中存放数据元素的数组要满足都满足如下特性：
1.最大的元素放在数组的索引1处。
2.每个结点的数据总是大于等于它的两个子结点的数据。

最大优先队列的swim和sink：
上浮：将当前结点k和父节点作比较，若k结点大于父结点，则交换k和父节点
下沉：求出当前结点的两个子节点的最大值max，若当前结点k小于max，则交换max和k
（数据大的往前放）

其实我们之前实现的堆可以把它叫做最大堆，我们可以用相反的思想实现最小堆，让堆中存放数据元素的数组满足
如下特性：
1.最小的元素放在数组的索引1处。
2.每个结点的数据总是小于等于它的两个子结点的数据。

最小优先队列的swim和sink
上浮：将当前结点k和父节点作比较，若k结点小于父结点，则交换k和父节点
下沉：求出当前结点的两个子节点的最小值min，若当前结点k大于min，则交换min和k
（数据小的往前放）

实现：

public class minPriorityQueue<T extends Comparable> {

    private T[] items; //优先队列基于堆的结构来实现，所以也用数组
    private int N;

    public minPriorityQueue(int capacity) {
        this.N = 0;
        this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
    }


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

    private boolean less(int i, int j) { //比较
        return (items[i].compareTo(items[j]) <0);
    }

    public void insert(T t) {
        items[++N] = t; //使用++N能废弃掉0索引；新加入的元素索引为N
        swim(N); //对索引N的元素使用上浮方法使其有序
    }

    public T delMin() {
        T min = items[1]; //仅记录要删除的最大元素
        swap(1, N);// 将最小元素和索引N处元素交换
        items[N] = null; //删除最小元素
        N--;
        sink(1);  // 通过sink方法让堆变得有序
        return min;
    }

    private void swim(int k) {
        while (k > 1) { //如果k已经到了根节点，则不再需要循环
            if (less(k, k / 2)) { //如果当前结点k小于父结点，则交换
                swap(k, k / 2);
                k = k / 2;
            } else {
                break;
            }
        }
    }

    private void sink(int k) {
        int min;
        while (2 * k <= N) { //k存在左子节点
            if (2 * k + 1 <= N) { //且存在右子节点
                //找出左右子节点的最小
                if (less(2 * k, 2 * k + 1)) { //如果左小于右
                    min = 2 * k;
                } else {
                    min = 2 * k + 1;
                }

            } else { //只有左子结点
                min = 2 * k;
            }

            //比较当前k结点和max
            if (!less(k, min)) {
                swap(k, min);//当前结点k大于子节点中最小，则交换
                k = min;
            } else {
                break;
            }
        }
    }


    public int size() {
        return N;
    }


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

    public static void main(String[] args) {
        minPriorityQueue<String> p = new minPriorityQueue<String>(20);
        p.insert("A");
        p.insert("B");
        p.insert("C");
        p.insert("D");
        p.insert("E");
        p.insert("F");
        p.insert("G");

        while (!p.isEmpty()) {
            String s = p.delMin();
            System.out.print(s + " ");
        }
    }
}

测试结果：（小的优先取出） A B C D E F G