【6.优先级队列(堆) PriorityQueue】

优先级队列简介

队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，在这种情况下，数数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象优先级队列(Priority Queue）
JDK1.8中的PriorityQueue底层使用了堆这种数据结构，而堆实际就是在完全二叉树的基础上进行了一些调整

堆简介

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

堆的实现

package MyHeap;

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
class Incmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }
}
public class MyHeap {
    public int[] elem;
    public int usedSize;
    public MyHeap() {
        this.elem = new int [10];
    }
    public void initHeap(int[] array){
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
    }
    public void createHeap(){
        for (int parent = (usedSize-1-1)/2; parent >=0; parent--) {
            shiftDown(parent,usedSize);
        }
    } //建堆 向下时间复杂度为O(N)  向上时间复杂度为O(N*log2(N))
    private void shiftDown(int parent,int len){
        int child = parent*2+1;
        while (child < len){
            if(child + 1 < len && elem[child] < elem[child+1]){
                child++;
            }
            if (elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child;
                child = parent*2 + 1;
            } else {
                break;
            }
        }

    } //向下调整
    public void offer(int val){
        if(isFull()){
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize++] = val;
        shiftUp(usedSize-1);
    }
    private void shiftUp(int child){
        int parent = (child-1)/2;
        while (child > 0){
            if(elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                child = parent;
                parent = (child-1)/2;
            } else {
                break;
            }
        }
    } //向上调整
    public boolean isFull() {
        return usedSize == elem.length;
    }
    public boolean isEmpty() {
        return usedSize == 0;
    }
    public int[] getBiggestNumbers(int[] arr, int k) {
        if(arr == null|| k <=0){
            return null;
        }
        Queue<Integer> pQ = new PriorityQueue<>(k);
        int[] ret = new int[k];
        for (int i = 0; i < k; i++) {
            pQ.offer(arr[i]);
        }
        for (int i = k; i < arr.length; i++) {
            if(pQ.peek() < arr[i]){
                pQ.poll();
                pQ.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; i++) {
            ret[i] = pQ.poll();
        }
        return ret;
    } // 最大K个数 建小堆
    public void pop() {
        if(isEmpty()){
            return;
        }
        int temp = elem[0];
        elem[0] = elem[usedSize-1];
        elem[usedSize-1] = temp;
        usedSize--;
        shiftDown(0,usedSize);
    }
    public void heapSort(){
        int end = usedSize-1;
        while (end > 0){
            int tem = elem[0];
            elem[0] = elem[end];
            elem[end] = tem;
            shiftDown(0,end);
            end--;
        }
    } //堆排序 时间复杂度为O(N*logN)


}