《黑马程序员》- 优先队列（最大or最小）

定义

优先队列，顾名思义，队列中的元素有优先级。

优先队列按照其作用不同，可以分为以下两种：

（1）最大优先队列：可以获取并删除队列中最大的值

最大优先队列：无论入队的顺序，当前最大的元素先出列。

（2）最小优先队列：可以获取并删除队列中最小的值

最小优先队列：无论入队的顺序，当前最小的元素先出列。

最大优先队列

堆这种结构是可以方便的删除最大的值，所以可以直接用堆结构实现最大优先队列。

堆结构： https://blog.csdn.net/Amigo_1997/article/details/118441974?spm=1001.2014.3001.5501

最小优先队列

也是通过堆的思想来实现，但是之前讲的堆特点如下，可以称为最大堆

1. 最大的元素放在数组的索引 1 处。

2. 每个结点的数据总是大于等于它的两个子结点的数据。

而最小堆则利用相反的思想，特点如下

1. 最小的元素放在数组的索引 1 处。

2. 每个结点的数据总是小于等于它的两个子结点的数据。

package tree2;

public class MinPriorityQueue <T extends Comparable<T>>{
    private T[] items;
    private int N;

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

    // 获取队列中元素的个数
    public int size(){
        return N;
    }
    // 判断队列是否为空
    public boolean isEmpty(){
        return N==0;
    }
    // 判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i, int j){
        return items[i].compareTo(items[j])<0;
    }
    // 交换堆中的元素值
    private void exch(int i, int j){
        T tmp = items[i];
        items[i] = items[j];
        items[j] = tmp;
    }
    // 往堆中插入一个元素
    public void insert(T t){
        items[++N] = t;
        swim(N);
    }
    // 删除堆中最小的元素，并返回这个最小元素
    public T delMin(){
        T min = items[1];
        exch(1,N);
        N--;
        sink(1);
        return min;
    }

    // 上浮算法
    private void swim(int k){
        while(k>1){
            if(less(k,k/2)){  // k/2是父节点
                exch(k,k/2);
            }
            k = k/2;
        }
    }

    // 下沉算法
    private void sink(int k){
        while(2*k<=N){  // 2*k是左子节点
            int min; //索引值
            if(2*k+1<=N){
                if(less(2*k,2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }

            //判断当前结点和较小值的大小
            if(less(k,min)){
                break;
            }
            exch(k,min);
            k=min; //这里容易写反
        }
    }
}