优先级队列(堆)
本节目标
- 掌握堆的概念及实现
- 掌握 PriorityQueue的使用
1. 二叉树的顺序存储
1.1 存储方式
使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。
一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。
这种方式的主要用法就是堆的表示
1.2 下标关系
已知双亲(parent)的下标，则：
左孩子(left)下标 = 2 * parent + 1;
右孩子(right)下标 = 2 * parent + 2;
已知孩子（不区分左右）(child)下标，则：
双亲(parent)下标 = (child - 1) / 2; //向上取整
2. 堆(heap)
2.1 概念
- 堆逻辑上是一棵完全二叉树
- 堆物理上是保存在数组中
- 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆
- 反之，则是小堆，或者小根堆，或者最小堆
- 堆的基本作用是，快速找集合中的最值
2.2 操作-向下调整-建堆
前提：左右子树必须已经是一个堆，才能调整。
说明：
- array代表存储堆的数组
- size代表数组中被视为堆数据的个数
- index代表要调整位置的下标
- left代表 index左孩子下标
- right代表 index右孩子下标
- min代表 index的最小值孩子的下标
过程（以小堆为例）：
- index如果已经是叶子结点，则整个调整过程结束
1.1 判断 index位置有没有孩子
1.2 因为堆是完全二叉树，没有左孩子就一定没有右孩子，所以判断是否有左孩子
1.3 因为堆的存储结构是数组，所以判断是否有左孩子即判断左孩子下标是否越界，即 left >= size越界 - 确定 left或 right，谁是 index的最小孩子 min
2.1 如果右孩子不存在，则 min = left
2.2 否则，比较 array[left]和 array[right]值得大小，选择小的为 min - 比较 array[index]的值和 array[min]的值，如果 array[index] <= array[min]，则满足堆的性质，调整结束
- 否则，交换 array[index]和 array[min]的值
- 然后因为 min位置的堆的性质可能被破坏，所以把 min视作 index，向下重复以上过程
过程（以大堆为例）
// 调整前
int[] array = {
27,15,19,18,28,34,65,49,25,37 };
// 调整后
int[] array = {
65,49,34,25,37,27,19,18,15,28 };
以大堆为例的代码：
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* User: 12629
* Date: 2022/1/22
* Time: 10:18
* Description:
*/
public class TestHeap {
public int[] elem;
public int usedSize;
public TestHeap() {
this.elem = new int[10];
}
/**
* 向下调整函数的实现
* @param parent 每棵树的根节点
* @param len 每棵树的调整的结束位置 10
*/
public void shiftDown(int parent,int len) {
int child = 2*parent+1;
//1、最起码 是有左孩子的，至少有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 = 2*parent+1;
}else {
break;
}
}
}
public void createHeap(int[] array) {
for (int i = 0; i < array.length; i++) {
elem[i] = array[i];
usedSize++;
}
//根据代码 显示的时间复杂度 看起来 应该是O(n*logn) 但是 实际上是O(n)
for (int parent = (usedSize-1-1)/2; parent >= 0 ; parent--) {
//调整
shiftDown(parent,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 void offer(int val) {
if(isFull()) {
//扩容
elem = Arrays.copyOf(elem,2*elem.length);
}
elem[usedSize++] = val;
//注意这里传入的是usedSize-1
shiftUp(usedSize-1);
}
public boolean isFull() {
return usedSize == elem.length;
}
public int poll() {
if(isEmpty()) {
throw new RuntimeException("优先级队列为空！");
}
int tmp = elem[0];
elem[0] = elem[usedSize-1];
elem[usedSize-1] = tmp;
usedSize--;
shiftDown(0,usedSize);
return tmp;
}
public int peek() {
if(isEmpty()) {
throw new RuntimeException("优先级队列为空！");
}
return elem[0];
}
public boolean isEmpty() {
return usedSize == 0;
}
//堆排序
public void heapSort() {
int end = this.usedSize-1;
while (end > 0) {
int tmp = elem[0];
elem[0] = elem[end];
elem[end] = tmp;
shiftDown(0,end);
end--;
}
}
}
向下调整时间复杂度分析：
最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度
向下调整的时间复杂度为：O(logn)
建堆的时间复杂度分析：
粗略估算，可以认为是在循环中执行向下调整，为 O(n * log(n))（了解）实际上是 O(n)
堆排序中建堆过程时间复杂度O(n)怎么来的？
2.3 操作-入队列
过程（以大堆为例）：
1.首先按尾插方式放入数组
2.比较其和其双亲的值的大小，如果双亲的值大，则满足堆的性质，插入结束
3.否则，交换其和双亲位置的值，重新进行 2、3步骤
4.直到根结点
2.4 操作-出队列（优先级最高）
为了防止破坏堆的结构，删除时并不是直接将堆顶元素删除，而是用数组的最后一个元素替换堆顶元素，然后通过向
下调整方式重新调整成堆
2.5 返回队首元素（优先级最高）
返回堆顶元素即可
3.堆的应用-优先级队列
3.1 概念
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)
3.2 内部原理
优先级队列的实现方式有很多，但最常见的是使用堆来构建。
PriorityQueue默认是一个小根堆
public static void main2(String[] args) {
//默认就是一个小根堆
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
//每放一个元素 都得保证当前的堆 是大堆 或者是小堆
priorityQueue.offer(12);
priorityQueue.offer(3);
priorityQueue.offer(15);
System.out.println(priorityQueue.poll());
System.out.println(priorityQueue.poll());
}
3.3 PriorityQueue常用接口：
构造方法：
无参构造函数：
有源码可以看出他的初始默认容量为11
扩容机制：
public static void TestPriorityQueue(){
// 创建一个空的优先级队列，底层默认容量是11
PriorityQueue<Integer> q1 = new PriorityQueue<>();
// 创建一个空的优先级队列，底层的容量为initialCapacity=100
PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
ArrayList<Integer> list = new ArrayList<>();
list.add(4);
list.add(3);
list.add(2);
list.add(1);
// 用ArrayList对象来构造一个优先级队列的对象
PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
System.out.println(q3.size());
System.out.println(q3.peek());
其他接口：
一般使用offer、poll、peek
4. 堆的其他应用-TopK问题
拜托，面试别再问我TopK了！！！
关键记得，找前 K个最大的，要建 K个大小的小堆
LeetCode题 373. 查找和最小的 K 对数字
和TopK问题的思路三代码实现
Java代码：
import java.util.*;
/**
* Created with IntelliJ IDEA.
* User: 12629
* Date: 2022/1/23
* Time: 11:08
* Description:
*/
public class TopK {
/**
* 求数组当中的前K个最小的元素
* @param array
* @param k
* @return
*/
public static int[] topK(int[] array,int k) {
//1、创建一个大小为K的大根堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
//2、遍历数组当中的元素，前K个元素放到队列当中
for (int i = 0; i < array.length; i++) {
if(maxHeap.size() < k) {
maxHeap.offer(array[i]);
}else {
//3、从第k+1个元素开始，每个元素和堆顶元素进行比较
int top = maxHeap.peek();
if(top > array[i]) {
//3.1 先弹出
maxHeap.poll();
//3.2 后存入
maxHeap.offer(array[i]);
}
}
}
int[] tmp = new int[k];
for (int i = 0; i < k; i++) {
tmp[i] = maxHeap.poll();
}
return tmp;
}
//LeetCode题 373. 查找和最小的 K 对数字 方法一：测试用例33/35
public static List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
PriorityQueue<List<Integer>> maxHeap = new PriorityQueue<>(k, new Comparator<List<Integer>>() {
@Override
public int compare(List<Integer> o1, List<Integer> o2) {
return (o2.get(0)+o2.get(1))-(o1.get(0)+o1.get(1));
}
});
// for (int i = 0; i < Math.min(nums1.length,k); i++) {
// for (int j = 0; j < Math.min(nums2.length,k); j++) {
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
if(maxHeap.size() < k) {
List<Integer> tmpList = new ArrayList<>();
tmpList.add(nums1[i]);
tmpList.add(nums2[j]);
maxHeap.offer(tmpList);
}else {
int top = maxHeap.peek().get(0) + maxHeap.peek().get(1);
if(top > nums1[i]+nums2[j]) {
//记住 要弹出的
maxHeap.poll();
List<Integer> tmpList = new ArrayList<>();
tmpList.add(nums1[i]);
tmpList.add(nums2[j]);
maxHeap.offer(tmpList);
}
}
}
}
List<List<Integer>> ret = new ArrayList<>();
for (int i = 0; i < k && !maxHeap.isEmpty(); i++) {
ret.add(maxHeap.poll());
}
return ret;
}
//LeetCode题 373. 查找和最小的 K 对数字 方法二：测试用例35/35
public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) return null;
List<List<Integer>> smallestPairs = new ArrayList<>();
int n = nums1.length;
int m = nums2.length;
PriorityQueue<int[]> queue = new PriorityQueue<>(k, (a, b) ->
(nums1[a[0]] + nums2[a[1]]) - (nums1[b[0]] + nums2[b[1]]));
// 1. 维护 K 个元素到堆中 : (i, 0)
for (int i = 0; i < Math.min(n, k); i++) {
queue.add(new int[]{
i, 0});
}
// 2. 取出堆顶元素并加入新元素
while (k > 0 && !queue.isEmpty()) {
int[] pairs = queue.poll();
List<Integer> list = new ArrayList<>();
list.add(nums1[pairs[0]]);
list.add(nums2[pairs[1]]);
smallestPairs.add(list);
if(pairs[1] + 1 < m) queue.add(new int[]{
pairs[0], pairs[1] + 1});
k--;
}
return smallestPairs;
}
public static void main(String[] args) {
int[] nums1 = {
1,7,11};
int[] nums2 = {
2,4,6};
List<List<Integer>> ret = kSmallestPairs(nums1,nums2,2);
System.out.println(ret);
}
public static void main1(String[] args) {
int[] array = {
18,21,8,10,34,12};
int[] tmp = topK(array,3);
System.out.println(Arrays.toString(tmp));
}
}
LeetCode题 373 方法二思路：
堆的常规解题方式：以K小为例
方式一：结果为堆中元素
- 对于单个序列的TopK问题，首先将序列的前 k 个元素添加到大根堆(降序)中
- 然后遍历剩下的 n - k 个元素，逐个判断其与堆顶元素的大小，当前元素小时，取出堆顶，加入当前元素(堆调整)最终堆中剩余的 k个元素就是TopK
方式二：结果为堆中每次取出的元素
- 对于多个序列的TopK问题，如本题是有两个独立的数组，需要先对各个子序列排序
- 接着同样在小根堆(升序)中维护对应序列个数个元素，然后每次取出堆顶元素，并加入当前堆顶元素(最小值)所在序列的下一个值，一共进行 k 次
- 取出的元素组成的集合( k 个)就是TopK，这种方式也成为多路归并，常见于大文件排序、海量数据排序等场景(面试热点)
本题的解题步骤
- 本题对应第二种方式的情况，但由于本题求解的数对，所以与普通的解法有一点区别
- 由于本题给出的两个数组都是升序数组，可以发现，数对(num1[0], nums2[0])是最小的数对，且对于 nums1中的一个元素，其与 nums2 中每个元素组成的数对序列也是升序的，反之亦然
- 因此，当求解过程中确定了 (num1[i], nums2[j]) 为一个 TopK后，下一个TopK应该是从堆中已有元素和 (num1[i+1], nums2[j])、(num1[i], nums2[j+1]) 中产生
- 首先我们将 k 个元素放入小根堆中，为了避免后续查找TopK时加入元素重复的问题，初始时以其中一个数组为基础，加入(0,0), (1,0), … , (k-1, 0)这些元素，当取出一个元素 (i, j) 后，新加入的元素为(i, j + 1)
- 取出的元素组成的就是TopK集合
复杂度分析：n 和 m 分别是两个数组的大小，k 是要求的数对个数
时间复杂度：O(k∗log(min(n,k)))，初始堆O(min(k,n))，堆调整O(log(min(n,k)))
空间复杂度：O(min(n,k)