优先级队列（堆）

目录

1. 堆的定义

2. 堆的基本操作

3. Top -- K问题

4. 堆排序

---

1. 堆的相关定义

优先级队列的概念

前面介绍过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队 列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如 果有来电，那么系统应该优先处理打进来的电话；初中那会班主任排座位时可能会让成绩好的同学先挑座位。

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

实现

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

堆的概念

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

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

堆的存储方式

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

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

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

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

堆的创建

堆向下调整

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

 仔细观察上图后发现：根节点的左右子树已经完全满足堆的性质，因此只需将根节点向下调整好即可。

向下过程(以小堆为例)：

我们用parent节点通过（child == 2*parent+1 || child == 2*parent+2）的关系去寻找child节点，并判断parent节点和child节点的大小关系去进行调整。

2. 堆的基本操作

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

PriorityQueue的特性

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

import java.util.PriorityQueue

2. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出 ClassCastException异常

3. 不能插入null对象，否则会抛出NullPointerException

4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容

5. 插入和删除元素的时间复杂度为O(log2N)

6. PriorityQueue底层使用了堆数据结构 7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素 

常用接口介绍

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

// 用户自己定义的比较器：直接实现Comparator接口，然后重写该接口中的compare方法即可
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(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);

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

3. Top -- K问题

leetcode:面试题 17.14. 最小K个数 - 力扣（LeetCode）

我在一开始做这题时的思路很简单，就是创建一个堆，由于原本提供的堆结构已经是小根堆了，因此我们只需弹出前k个数就好了。

一般思路：

 public int[] smallestK(int[] arr, int k) {
        PriorityQueue<Integer> minheap = new PriorityQueue<>();
        for(int i = 0;i < arr.length;i++){
            minheap.offer(arr[i]);
        }
        int ans[] = new int[k];
        for(int i = 0;i < ans.length;i++){
            int val = minheap.poll();
            ans[i] = val;
        }
        return ans;
    }

时间复杂度：O((N+K)*logN) 

但后来我了解到，由于这题是面试题的特殊性，面试官更想考察你对算法的敏感度，对你这个解法不是很满意 ，那么如何进行优化呢？

常见的思路：

正难则反，我们可以通过创建一个K个数的大根堆，并用这个堆比较后续的N-K个元素，如果这个元素比堆顶元素小，就插入，堆顶元素弹出，并对它进行向下调整，最后，我们便可以得到一个前K个小的堆。

class Intcmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1,Integer o2){
        return o2.compareTo(o1);
    }


}
public int[] smallK(int[] arr,int k) {
        //创建大根堆
        PriorityQueue<Integer> maxheap = new PriorityQueue<>(new Intcmp());
        //将k个元素放进堆里
        for (int i = 0; i < k; i++) {
            maxheap.offer(arr[i]);
        }
        //比较后续元素
        for (int i = k; i < arr.length; i++) {
            int tmp = maxheap.peek();
            if (tmp > arr[i]) {
                maxheap.poll();
                maxheap.offer(arr[i]);
            }
        }
        int[] ans = new int[k];
        for (int i = 0; i < k; i++) {
            ans[i] = maxheap.poll();
        }
        return ans;
    }

4. 堆排序

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

1. 建堆

• 升序：建大堆
• 降序：建小堆

2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。 

常见习题：

1.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为()

A: (11 5 7 2 3 17) B: (11 5 7 2 17 3) C: (17 11 7 2 3 5) D: (17 11 7 5 3 2) E: (17 7 11 3 5 2) F: (17 7 11 3 2 5)

答案：C 

public void heapSort() {
        //前提先是一个大根堆
        int endIndex = useSize -1;
        while (endIndex > 0) {
            swap(0,endIndex);
            siftdown(0,endIndex);
            endIndex--;
        }
    }