最大堆优先队列

优先队列
普通的队列是一种先进先出的数据结构，元素在队列尾部追加，从而队列头删除。在某些情况下，我们可能需要找出队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下，计算机的任务都是有优先级的，我们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。普通的队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就可以使用一种特殊的队列完成这种需求，优先队列。

最大优先队列API设计；
类名：MaxPriorityQueue

构造方法：public MaxPriorityQueue(int capacity)：创建容量为capacity的MaxPriorityQueue对象；
成员方法：
1：public int size()：获取队列中元素的个数
2： public boolean isEmpty()：断队列是否为空
3：private boolean less(int i,int j)：判断堆中索引i处的元素是否小于索引j处的元素
4： private void exch(int i,int j)：交换堆中i索引和j索引处的值
5： public void insert(T t)：往堆中插入一个元素
6： public T delMax()：删除堆中最大的元素，并返回这个最大元素
7：private void swim(int k)：使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
8：private void sink(int k)：使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
 

package com.test;

import java.util.Comparator;

/**
 * @Author zongx
 * @Date 2020/5/25 13:43
 * @Version 1.0
 */
public class MaxPriorityQueue<T extends Comparable<T>> {
    //存储堆中的元素
    private T[] items;
    //堆中元素格式
    private int N;

    public MaxPriorityQueue(int capacity) {
        this.items = (T[]) new Comparable[capacity+1];
        this.N = 0;
    }

    //获取元素个数
    public int size() {
        return this.N;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return this.N == 0;
    }

    //判断堆中索引i处的值是否小于索引j处的值
    public boolean less(int i, int j) {
        return items[i].compareTo(items[j])<0;
    }

    //交换堆中i索引与j索引处的值
    public void exch(int i, int j) {
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    //往堆中插入一个元素
    public void insert(T t) {
        items[++N] = t;
        swim(N);
    }

    //删除堆中最大的元素
    public T delMax() {
        T max = items[1];
        exch(1,N);
        N--;
        sink(1);
        return max;
    }

    //使用上浮算法，使索引k处的值处于一个正确的位置
    private void swim(int k) {
        while (k > 1) {
            // k/2小于k，则交换位置
            if (less(k/2, k)) {
                exch(k/2, k);
            }
            k = k/2;
        }
    }

    //使用下沉算法，使索引k处的值处于一个正确的位置
    private void sink(int k) {
        while (2 * k <= N) {
            int max;
            if (2 * k + 1 <= N) {
                if(less(2 * k, 2 * k + 1)) {
                    max = 2 * k + 1;
                }else {
                    max = 2 * k;
                }
            }else {
                max = 2 * k;
            }

            if (less(k ,max)) {
                exch(k, max);
                k = max;
            }else {
                break;
            }
        }
    }
}

package com.test;

public class MaxPriorityQueueTest {
    public static void main(String[] args) {
        //创建优先队列
        MaxPriorityQueue<String> queue = new MaxPriorityQueue<String>(15);
        //往队列中存储元素
        queue.insert("a");
        queue.insert("m");
        queue.insert("b");
        queue.insert("l");
        queue.insert("c");
        queue.insert("k");
        queue.insert("d");
        queue.insert("j");
        queue.insert("e");
        queue.insert("i");
        queue.insert("f");
        queue.insert("h");
        queue.insert("g");
        //通过循环从队列中获取最大的元素
        while (!queue.isEmpty()){
            String max = queue.delMax();
            System.out.print(max+" ");
        }
    }
}