【数据结构】---优先级队列和堆

一、优先级队列
1.1 概念

• 队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该种场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。

1.2模拟实现

• JDK1.8中的PriorityQueue底层使用了堆的数据结构，而堆实际就是在完全二叉树的基础之上进行了一些元素的调整。

二、堆
2.1 堆的概念

• 如果有一个关键码的集合K = {k0，k1，
  k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<=
  K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为
  小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

2.2 堆的性质

• 堆中某个节点的值总是不大于或不小于其父节点的值；
• 堆总是一棵完全二叉树。

2.3 堆的存储方式

• 从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储
• 对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。

2.4 堆的创建

public class Heap {
    public int[] elem;
    public int usedSize;

    public Heap(int[] elem, int usedSize) {
        this.elem = elem;
        this.usedSize = usedSize;
    }
    //1 初始化
    public void initArray(int[] array){
        elem= Arrays.copyOf(array,array.length*1);
    }
    //2 建堆:对所有的根结点进行向下调整
    public void createHeap(int[] elem){
        for(int parent=(usedSize-1-1)/2;parent>=0;parent--){
            turnDown(parent,usedSize);
        }
    }
    public void turnDown(int parent,int usedSize){//每次只需要比较最大的那棵树就行
        int child=2*parent+1;
        while(child<usedSize){//至少左孩子存在，说明循环成立，还没有结束
            if(child+1<usedSize && elem[child+1]>elem[child]){//如果右孩子也存在
                child=child+1;
            }
            if(elem[child]>elem[parent]){
                swap(elem,child,parent);
                parent=child;
                child=2*parent+1;
            }else{
                break;
            }
        }
    }
    public void swap(int[] elem,int child,int parent){
        int tmp=elem[parent];
        elem[parent]=elem[child];
        elem[child]=tmp;
    }
}

2.5 堆的插入

    //3 堆的插入:插入最后，向上调整
    public void push(int val){
        if(isFull()){
            elem=Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize++]=val;
        int child=usedSize-1;
        turnUp(child);
    }
    public void turnUp(int child){
        for(child=usedSize-1;child>0;child--){
            int parent=(child-1)/2;
            if(elem[child]>elem[parent]){
                swap(elem,child,parent);
                child=parent;
                parent=(child-1)/2;
            }else{
                break;
            }
        }
    }
    private boolean isFull(){
        return usedSize==elem.length;
    }

2.6 堆的删除

   //4 堆的删除：交换第一与最后，调整最大的那棵树
    public int poll(){
        if(isEmpty()){
            return -1;
        }
        int ret=elem[0];
        swap(elem,elem[0],elem[usedSize-1]);
        usedSize--;
        turnDown(0,usedSize);
        return ret;
    }
    private boolean isEmpty(){
        return usedSize==0;
    }

    public void heapSort(){
        int end=usedSize-1;
        swap(elem,0,end);
        turnDown(0,end);
        end--;
    }

三、常用接口：PriorityQueue
3.1 特性

（1）. 使用时必须导入PriorityQueue所在的包；
（2）. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出
ClassCastException异常；
（3）. 不能插入null对象，否则会抛出NullPointerException；
（4）. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容；
（5）. PriorityQueue底层使用了堆数据结构；
（6）. PriorityQueue默认情况下是小堆—即每次获取到的元素都是最小的元素；

3.2 优先队列的构造

static void TestPriorityQueue(){
// 1 创建一个空的优先级队列，底层默认容量是11
PriorityQueue<Integer> q1 = new PriorityQueue<>();


//2  创建一个空的优先级队列，底层的容量为initialCapacity
PriorityQueue<Integer> q2 = new PriorityQueue<>(100);


ArrayList<Integer> list = new ArrayList<>();
list.add(4);
list.add(3);
list.add(2);
list.add(1);
// 3 用ArrayList对象来构造一个优先级队列的对象
// q3中已经包含了三个元素
PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
System.out.println(q3.size());
System.out.println(q3.peek());
}

• 注意：默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器

// 用户自己定义的比较器：直接实现Comparator接口，然后重写该接口中的compare方法即可
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class TestPriorityQueue {
public static void main(String[] args) {
PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
p.offer(4);
p.offer(3);
p.offer(2);
p.offer(1);
p.offer(5);
System.out.println(p.peek());
}
}

3.3 插入/删除/获取优先级最高的元素

• 优先级队列的扩容说明：

（1）. 如果容量小于64时，是按照oldCapacity的2倍方式扩容的；
（2）. 如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的；
（3）. 如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容；

3.4 优先级队列的应用

top-k问题：最大或者最小的前k个数据。比如：世界前500强公司

四、堆的应用
4.1 PriorityQueue的实现

• 用堆作为底层结构封装优先级队列

4.2 堆排序

    public void heapSort(){
        int end=usedSize-1;
        swap(elem,0,end);
        turnDown(0,end);
        end--;
    }