【数据结构与算法】优先级队列(堆)

一.优先级队列

1.1 概念

队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。

在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。

---

二.优先级队列的模拟实现

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 堆的存储方式

从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储

注意：对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。

将元素存储到数组中后，可以根据二叉树性质对树进行还原。假设 i 为节点在数组中的下标，则有：

• 如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
• 如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子
• 如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子

2.3 堆的创建

2.3.1 堆向下调整

1. 让 parent 标记需要调整的节点，child 标记 parent 的左孩子(注意：parent 如果有孩子一定先是有左孩子)
2. 如果 parent 的左孩子存在，即: child < size， 进行以下操作，直到parent 的左孩子不存在

• parent 右孩子是否存在，存在找到左右孩子中最大的孩子，让child进行标
• 将 parent 与较大的孩子child比较，如果：
  parent 大于较大的孩子child，调整结束，否则：交换 parent 与较大的孩子child，交换完成之后，parent 中小的元素向下移动，可能导致子树不满足堆的性质，因此需要继续向下调整，即 parent = child；child = parent*2+1; 然后继续2。

注意：在调整以parent为根的二叉树时，必须要满足parent的左子树和右子树已经是堆了才可以向下调整。

时间复杂度分析：

最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为 Olog2(n)

2.3.2 堆的创建

对于集合{ 27,15,19,18,28,34,65,49,25,37 }中的数据，如果将其创建成堆呢？

1. 从最后一棵子树开始调整

2. 每棵子树调整的时候，都是向下调整。

1. 如何确定最后一棵子树的根节点。
   p = (len-1-1)/2->是不是就是最后一棵子树的根节点 ! !
2. 调整完一棵树之后，怎么到下一棵树?
   p - -
3. 直到调整完 0 下标这棵树就好了。

public static void main1(String[] args) {
     TestHeap testHeap = new TestHeap();
     int[] array = { 27,15,19,18,28,34,65,49,25,37 };
     testHeap.createHeap(array);
 }

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

    public TestHeap() {
        this.elem = new int[10];
    }

    /**
     * 建堆的时间复杂度：
     */
    public void createHeap(int[] array) {
        //这一步不算是必须的。这里只是我们准备数据，不算做我的建堆时间复杂度当中
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }

        for (int p = (usedSize-1-1)/2; p >= 0 ; p--) {
            shiftDown(p,usedSize);
        }
    }

    /**
     * @param root 是每棵子树的根节点的下标
     * @param len  是每棵子树调整结束的结束条件
     * 向下调整的时间复杂度：O(logn)
     */
    private void shiftDown(int root,int len) {
        int parent = root;
        int child = 2*parent+1;
        //进入这个循环，说明一定至少有一个孩子
        while (child < len) {
            //如果有孩子，找到左右孩子的最大值
            if(child+1 < len && elem[child] < elem[child+1]) {
                child++;
            }
            //child下标一定保存的是左右孩子最大值的下标
            //接下来，孩子的最大值和根节点去比较大小
            if(elem[child] > elem[parent]) {
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child;//开始更新下标，继续看下面的子树是不是大根堆
                child = 2*parent+1;
            }else {
                break;//此时说明已经是大根堆，不需要进行再次调整了
            }
        }
    }
}

2.3.3 建堆的时间复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)

因此：建堆的时间复杂度为O(N)。

---

2.4 堆的插入与删除

2.4.1 堆的插入

堆的插入总共需要两个步骤：

1. 先将元素放入到底层空间中(注意：空间不够时需要扩容)
2. 将最后新插入的节点向上调整，直到满足堆的性质

1. 从最后一棵子树开始向上调整，下标位置上面讲过
2. 直到c == 0 或者 p<0

/**
 * 入队：仍然要保持是大根堆
 * @param val
 */
public void push(int val) {
    if(isFull()) {
        elem = Arrays.copyOf(elem,2*elem.length);
    }
    //1、放到最后的位置
    elem[usedSize] = val;
    //2、进行向上调整
    shiftUp(usedSize);
    //3、有效数据+1
    usedSize++;
}

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;
}

2.4.2 堆的删除

注意：堆的删除一定删除的是堆顶元素。具体如下：

1. 将堆顶元素对堆中最后一个元素交换
2. 将堆中有效数据个数减少一个
3. 对堆顶元素进行向下调整

/**
 * 出队【删除】：每次删除的都是优先级高的元素
 * 仍然要保持是大根堆
 */
public void pollHeap() {
    if(isEmpty()) {
        System.out.println("优先级队列为空！");
        return;
    }
    int tmp = elem[0];
    elem[0] = elem[usedSize-1];
    elem[usedSize-1] = tmp;
    usedSize--;//9
    shiftDown(0,usedSize);
}

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

2.4.3 获取堆顶元素

/**
 * 获取堆顶元素
 * @return
 */
public int peekHeap() {
    if(isEmpty()) {
        System.out.println("优先级队列为空！");
        return -1;
    }
    return elem[0];
}

---

三.常用接口介绍

3.1.1 PriorityQueue 的特性

Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue 是线程不安全的，PriorityBlockingQueue 是线程安全的，本文主要介绍PriorityQueue。

关于 PriorityQueue 的使用要注意：

1. 使用时必须导入PriorityQueue所在的包，即：

import java.util.PriorityQueue;

2. PriorityQueue 中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出 ClassCastException 异常
3. 不能插入 null 对象，否则会抛出 NullPointerException
4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容
5. 插入和删除元素的时间复杂度为 O(log2(N))
6. PriorityQueue底层使用了堆数据结构, (注意：此处大家可以不用管什么是堆，后文中有介绍)
7. PriorityQueue默认情况下是小堆—即每次获取到的元素都是最小的元素

3.1.2 PriorityQueue常用接口介绍

1. 优先级队列的构造

构造器	功能介绍
PriorityQueue()	创建一个空的优先级队列，默认容量是11
PriorityQueue(int initialCapacity)	创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则会抛IllegalArgumentException异常
PriorityQueue(Collection<?extends E> c)	用一个集合来创建优先级队列

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

可以看到我们有如上两种方法去设置大小堆

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

函数名	功能介绍
boolean offer(E e)	插入元素e，插入成功返回true，如果e对象为空，抛NullPointerException异常，时间复杂度 O(log2(N)) ，注意：空间不够时候会进行扩容
E peek()	获取优先级最高的元素，如果优先级队列为空，返回null
E poll()	移除优先级最高的元素并返回，如果优先级队列为空，返回null
int size()	获取有效元素的个数
void clear()	清空
boolean isEmpty()	检测优先级队列是否为空，空返回true

优先级队列的扩容说明：

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

3.3 优先级队列的应用

top-k 问题：最大或者最小的前k个数据。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决

思路一：(例如前三个最大元素)

1、对整个数组进行排序，然后取前10个元素。
2、借助堆来进行操作前3个最大的
2.1 先将整体元素，建成最大堆
2.2 出队3次，这3个就是最大的

/**
 * 时间复杂度：O(n*logn)
 * @param array
 * @param k
 * @return
 */
public static int[] topK1(int[] array,int k) {
    IntCmp intCmp = new IntCmp();
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(intCmp);

    //n*logn
    for (int i = 0; i < array.length; i++) {
        priorityQueue.offer(array[i]);//插入堆中
    }
    //大堆创建完毕   n*logn
    int[] ret = new int[k];
    for (int i = 0; i < k; i++) {
        int val = priorityQueue.poll();
        ret[i] = val;
    }
    return ret;
}

思路二：（常用，推荐）

1. 用数据集合中前K个元素来建堆

• 前k个最大的元素，则建小堆
• 前k个最小的元素，则建大堆

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素，将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

1、先将数组前K个元素建成小根堆
2、从数组的第K+1个元素开始和堆顶元素比较。
3、如果当前i下标的元素，大于当前堆顶的值，那么堆顶元素出队，然后将i下标的值入堆。
4、直到遍历完整个数组，结束了!

/**
 * 求最小的 K个数
 * @param array  N*logk
 * @param k
 * @return
 */
public static int[] topK(int[] array,int k) {
    IntCmp intCmp = new IntCmp();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    });

    for (int i = 0; i < array.length; i++) {
        if(maxHeap.size() < k) {
            maxHeap.offer(array[i]);
        }else {
            int top = maxHeap.peek();
            if(array[i] < top) {
                maxHeap.poll();
                maxHeap.offer(array[i]);
            }
        }
    }
    int[] ret = new int[k];
    for (int i = 0; i < k; i++) {
        int val = maxHeap.poll();
        ret[i] = val;
    }
    return ret;
}

1. 第K大的元素怎么求?

小根堆顶元素就是

2. 第K小的元素怎么求?

大根堆顶元素就是

---

4.2 堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

从小到大排序：建大根堆

• 过程：
  1、建立大根堆
  2、0下标和end下标交换
  3、调整0下标这棵树 shiftDown(0,end)
  4、end–

从大到小排序：建小根堆

例如从小到大排序

//O(n*logn)
public void heapSort() {
    int end = usedSize-1;
    while (end > 0) {
        int tmp = elem[0];
        elem[0] = elem[end];
        elem[end] = tmp;
        shiftDown(0,end);
        end--;
    }
}