目录
一:优先级队列的概念
前面介绍过队列,队列是一种先进先出(FIFO)的数据结构,但有些情况下,操作的数据可能带有优先级,一般出队列时,可能需要优先级高的元素先出队列。
在这种情况下,我们的数据结构应该提供两个最基本的操作,一个是返回最高优先级对象,一个是添加新的对象。
这种数据结构就是优先级队列(Priority Queue)。
二:堆
我们直接看图,堆分为大根堆和小根堆:
性质:
- 堆中某个节点的值总是不大于或不小于其父节点的值;
- 堆总是一棵完全二叉树。
三:堆的存储方式
堆是一棵完全二叉树,因此可以按照层序遍历的规则采用顺序的方式来高效存储。
将元素存储到数组中后,可以根据二叉树章节的性质5对树进行还原。假设i为节点在数组中的下标,则有:
- 如果i为0,则i表示的节点为根节点,否则i节点的双亲节点为 (i - 1)/2;
- 如果2 * i + 1 小于节点个数,则节点i的左孩子下标为2 * i + 1,否则没有左孩子;
- 如果2 * i + 2 小于节点个数,则节点i的右孩子下标为2 * i + 2,否则没有右孩子。
四:堆的创建
我们采用的是向下调整的方式。以创建大根堆为例,如何将这棵完全二叉树调整为堆呢?
整体的思路是:
1.从最后一棵子树开始调整;
2.每次调整都是向下调整;
3.对于每一个根节点,将根节点的值与左右节点的最大值进行比较,如果根节点的值大于左右节点中的最大值,不作调整,否则将根节点与左右节点中的最大值交换。
一些小问题:
1.如何确定最后一棵子树的根节点?
p=(len-1-1)/2=len/2-1,其中len为数组长度。如上图这棵二叉树,len=10,p=(10-1-1)/2=4,即从4号节点开始调整。
2.调整完一棵树后,怎么到下一棵树?
p--;直到调整到下标为0的这棵树就好了。
3.每棵子树调整的结束位置如何确定?
对于一个节点是否需要进行调整,取决于它是否是根节点,换句话说,是否具有左右子树。所以每棵树调整时,其左右孩子的下标都不能超过或等于一个数字,就是len。如下标为4的节点左子树下标为9,9<10,所以需要继续调整;而下标为5的节点的左子树下标为10,10=10,就无需进行调整了。
依据上面的分析,写出代码:
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++;
}
//p = (usedSize-1-1) 确定最后一棵子树的根节点
for (int p = (usedSize-1-1)/2; p>=0 ; p--) {
shifDown(p,usedSize);
}
}
private void shifDown(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++;
}
//孩子的最大值和根节点去比较大小
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 class Test {
public static void main(String[] args) {
int[] array = { 27,15,19,18,28,34,65,49,25,37 };
TestHeap testHeap = new TestHeap();
testHeap.createHeap(array);
System.out.println("测试");
}
}
通过在打印语句处打断点进行调试,可以看到如下图所示结果,证明我们的创建是正确的!
关键问题:建堆的时间复杂度——O(N)!使用错位相减法。
五:堆的插入与删除
5.1堆的插入
堆的插入总共需要两个步骤:
1. 先将元素放入到底层空间中(注意:空间不够时需要扩容)
2. 将最后新插入的节点向上调整,直到满足堆的性质
图解:
//插入
public void push(int val){
if(isFull()) {
elem = Arrays.copyOf(elem, (int) (1.5 * elem.length)); //如果容量已满,进行1.5倍扩容
}
elem[usedSize] = val;
shifUp(usedSize);
usedSize++;
}
public void shifUp(int usedSize){
int child = usedSize;
int parent = (child-1)/2;
while(parent >= 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;
}
}
}
private boolean isFull(){
return elem.length == usedSize ;
}
通过在打印语句处打断点进行调试,可以看到如下图所示结果,证明我们的插入是正确的!
5.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;
}
5.3获取堆顶元素
/**
* 获取堆顶元素
* @return
*/
public int peekHeap() {
if(isEmpty()) {
System.out.println("优先级队列为空!");
return -1;
}
return elem[0];
}
六:常用接口介绍
6.1PriorityQueue的特性
Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列,PriorityQueue是线程不安全的,PriorityBlockingQueue是线程安全的,本文主要介绍PriorityQueue。
注意:
1. 使用时必须导入PriorityQueue所在的包,即import java.util.PriorityQueue;
2. PriorityQueue中放置的元素必须要能够比较大小,不能插入无法比较大小的对象,否则会抛出
ClassCastException异常;
3. 不能插入null对象,否则会抛出NullPointerException;
4. 没有容量限制,可以插入任意多个元素,其内部可以自动扩容;
5. 插入和删除元素的时间复杂度为O(logN);
6. PriorityQueue底层使用了堆数据结构;
7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素。
6.2使用实例
import java.util.PriorityQueue;
public class Test2 {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(12);
priorityQueue.offer(3);
priorityQueue.offer(24);
System.out.println(priorityQueue.peek());
System.out.println(priorityQueue.poll());
System.out.println(priorityQueue.peek());
}
}
默认情况下,PriorityQueue队列是小堆,如果需要大堆需要用户提供比较器。提供比较器的两种写法如下:
写法一:
import java.util.Comparator;
import java.util.PriorityQueue;
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class Test2 {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new IntCmp());
priorityQueue.offer(12);
priorityQueue.offer(3);
priorityQueue.offer(24);
System.out.println(priorityQueue.peek());
System.out.println(priorityQueue.poll());
System.out.println(priorityQueue.peek());
}
}
写法二:
import java.util.Comparator;
import java.util.PriorityQueue;
public class Test2 {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((a, b) -> {
return b - a;
});
priorityQueue.offer(12);
priorityQueue.offer(3);
priorityQueue.offer(24);
System.out.println(priorityQueue.peek());
System.out.println(priorityQueue.poll());
System.out.println(priorityQueue.peek());
}
}
6.3插入/删除/获取优先级最高的元素
七:堆的应用
7.1Topk问题
举例:找出世界500强的公司,找出专业前三十名,都是Topk问题。举例:
面试题 17.14. 最小K个数 - 力扣(LeetCode)https://leetcode.cn/problems/smallest-k-lcci/submissions/ 一种最简单的思路是,对整个数组进行排序,然后取出前k个元素即可。但如果数据量极大的话,这种方法则不可取。这时就需要用到优先级队列。
要找最小K个数,先将整体元素建成小根堆,然后出队K次。
class Solution {
public int[] smallestK(int[] arr, int k) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
//n*logn
for (int i = 0; i < arr.length; i++) {
priorityQueue.offer(arr[i]);//插入堆中
}
//小堆创建完毕 n*logn
int[] ret = new int[k];
for (int i = 0; i < k; i++) {
int val = priorityQueue.poll();
ret[i] = val;
}
return ret;
}
}
时间复杂度分析:假设一共有n个数据,每次插入一个数据都需要进行向上调整,时间复杂度为logn,所以总的时间复杂度为O(N*logN)。这个时间复杂度有点大,我会介绍一种优化算法:
要找前K个最大的元素,反其道而行之,不断把最小的元素剔除出去!
建立含有K个节点的小根堆,堆顶元素最小,如果当前元素比这个堆顶元素大,那么说明堆顶元素必不可能是前K个最大元素之一,就把堆顶元素剔除出去,把当前元素添加进去,每次添加后,都要再调整为小根堆。直到比较完所有的元素后,此时堆中所有的元素就是前K个最大元素。
时间复杂度分析:假设一共有n个数据,每次插入一个数据都需要进行向上调整,时间复杂度为logn,但是因为堆中元素为K个,所以总的时间复杂度为O(K*logN)。
代码实现:
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class Test2 {
//找前k个最小的元素,需要建立大根堆,不断把大元素剔除出去
public static int[] topK(int []array,int k){
PriorityQueue<Integer> maxHeap= new PriorityQueue<>(new IntCmp());
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]);
}
}
}
//此时大根堆中所有的元素就是前K个最小的元素
int[] ret = new int[k];
for (int i = 0; i < k; i++) {
int val = maxHeap.poll();
ret[i] = val;
}
return ret;
}
测试:
public static void main(String[] args) {
int[] arr = {1,0,2,5,7,8,9,36,874,45};
int[] ret = topK(arr,3);
System.out.println(Arrays.toString(ret));
}
7.2堆排序
堆排序即利用堆的思想来进行排序,总共分为两个步骤:
1. 建堆
升序:建大堆
降序:建小堆
2. 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整,因此掌握了向下调整,就可以完成堆排序。
以升序为例,具体步骤为:
1.先建立大根堆;
2.0下标和end下标交换;
3.调整0下标这棵树;
图解:
public void heapSort(){
int end = usedSize - 1;
while(end > 0){
int tmp = elem[0];
elem[0] = elem[end];
elem[end] = tmp;
end--;
shifDown(0,end);
}
}
public void shifDown(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++;
}
//孩子的最大值和根节点去比较大小
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 class Test {
public static void main(String[] args) {
int[] array = { 27,15,19,18,28,34,65,49,25,37 };
TestHeap testHeap = new TestHeap();
testHeap.createHeap(array);//O(n)
testHeap.heapSort();
System.out.println("测试");
}
}
运行结果如下:
显然实现了升序排列!
本课主要介绍优先级队列及其应用!!!