堆(Heap),又称为优先级队列(PriorityQueue),其逻辑结构本质为完全二叉树,存储结构为数组(层序遍历顺序存储)。按照优先级将堆分为大根堆以及小根堆,大根堆(大堆)中双亲节点的值一定大于其子女节点的值,小根堆(小堆)则相反,同时也意味着堆顶(队头)元素一定始终为所有元素中最大值或者最小值。
利用此数据结构的优先级规律,我们可以解决许多与比较相关的问题,本文将介绍其中两种:Top-k问题以及堆排序算法。
目录
(2)模拟实现优先级队列的部分(该代码也可见于本人博客:通过Java模拟实现堆(大根堆与小根堆)及其相关操作http://t.csdnimg.cn/08umN),重点在于向上调整方法:
(一)Top-k问题
1.题目描述
2.解决思路
此问题为典型的排序问题,可以借助任意的排序算法解决,但这里我们可以利用堆的特性:创建一个大小为k的大根堆,由于大根堆的堆顶(队头元素)一定为最大值,所以我们可以先将数组前k个元素存储放入堆中,然后再依次遍历剩余N-k个元素,若存在元素比堆顶元素小(即此时堆中元素并非为数组中最小的k个元素),则将原先堆顶元素出队,将该元素入队,最后完成题目。
3.代码示例
//创建一个类,其应用Comparator接口并且实现比较的相反逻辑
class IntReverseCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
//比较的相反逻辑
return o2.compareTo(o1);
}
}
class Solution {
public int[] smallestK(int[] arr, int k) {
//设定返回值
int[]ret=new int[k];
//k为0则直接返回
if(k==0){
return ret;
}
//Priority默认创建小根堆,因此使用应用了Comparator接口并且完成比较反逻辑的对象构造堆可以创建出大根堆
PriorityQueue<Integer> maxHeap=new PriorityQueue<>(new IntReverseCmp());
//将前k个元素放入堆中
for(int i=0;i<k;i++){
maxHeap.offer(arr[i]);
}
//遍历其余N-k个元素
for(int i=k;i<arr.length;i++){
int val=maxHeap.peek();
//判断其余元素是否比堆顶(队头)元素(堆中的最大元素),若小于则说明该元素可以放入堆中
if(arr[i]<val){
maxHeap.poll();
maxHeap.offer(arr[i]);
}
}
//将堆中元素放入返回的数组中
for(int i=0;i<k;i++){
ret[i]=maxHeap.poll();
}
return ret;
}
}
4.通过演示及分析
设数组元素个数为N,则该算法的时间复杂度为O(k^log k)[将前k个元素放入堆中,即利用向上调整的方式创建堆]+O((N-k)*log k) [最坏情况下剩余N-k个元素都要放入堆中]=O(N*log k)。
(二)堆排序
堆排序为八大排序中的一种,同样主要利用到堆的优先级特性实现。
1.代码结构
(1)HeapSort.java:
内包括MyPriorityQueue(模拟实现的优先级队列)类,其中包括堆排序方法。
(2)Test.java:
其中的main方法用于测试代码。
2.程序源码
(1)定义:
class MyPriorityQueue
(2)模拟实现优先级队列的部分(该代码也可见于本人博客:通过Java模拟实现堆(大根堆与小根堆)及其相关操作http://t.csdnimg.cn/08umN),重点在于向下调整方法:
//成员变量:1.数组的引用指向储存元素的数组2.usedSize记录数组存储的有效元素个数
public int[] elem;
public int usedSize;
//默认不带参数的构造方法
public MyPriorityQueue(){
this.elem=new int[10];
}
//利用给定数组初始化的方法
public void init(int[]array){
//数组存储大小不够则扩容
while(elem.length<array.length){
elem= Arrays.copyOf(elem,2*elem.length);
}
for(int i=0;i<array.length;i++){
elem[i]=array[i];
usedSize++;
}
}
//创建大根堆时调用到的向下调整的底层方法
private void maxSiftDown(int parent,int end){
//默认子女中的最大值为左子女
int child=2*parent+1;
while(child<end){
//判断右子女是否为二者中最大值
if(child+1<end){
if(elem[child]<elem[child+1]){
child++;
}
}
if(elem[parent]<elem[child]){
//子女节点中最大值大于双亲则进行交换调整
int temp=elem[parent];
elem[parent]=elem[child];
elem[child]=temp;
//向下迭代
parent=child;
child=2*parent+1;
}else{
//子女节点中最大值小于双亲说明该树已经为大根堆,无需向下调整,直接中断即可
break;
}
}
}
//创建一个大根堆的方法
public void createMaxHeap(){
//从最后一棵子树倒序调整
for(int parent=((usedSize-1-1)/2);parent>=0;parent--){
//调用向下调整的底层方法
maxSiftDown(parent,usedSize);
}
}
//创建小根堆时调用到的向下调整的底层方法
private void minSiftDown(int parent,int end){
//默认子女中的最小值为左子女
int child=2*parent+1;
while(child<end){
//判断右子女是否为二者中最小值
if(child+1<end){
if(elem[child]>elem[child+1]){
child++;
}
}
if(elem[parent]>elem[child]){
//子女节点中最小值小于双亲则进行交换调整
int temp=elem[parent];
elem[parent]=elem[child];
elem[child]=temp;
//向下迭代
parent=child;
child=2*parent+1;
}else{
//子女节点中最小值大于双亲说明该树已经为小根堆,无需向下调整,直接中断即可
break;
}
}
}
//创建一个小根堆的方法
public void createMinHeap(){
//从最后一棵子树倒序调整
for(int parent=((usedSize-1-1)/2);parent>=0;parent--){
//调用向下调整的底层方法
minSiftDown(parent,usedSize);
}
}
//插入元素时用到的底层判满方法
private boolean isFull(){
return elem.length==usedSize;
}
//大根堆插入元素时调用到的向上调整的底层方法
private void maxSiftUp(int child){
int parent=(child-1)/2;
while(parent>=0){
//如果子女节点的值大于双亲节点的值则进行交换调整
if(elem[child]>elem[parent]){
int temp=elem[child];
elem[child]=elem[parent];
elem[parent]=temp;
//向上迭代
child=parent;
parent=(child-1)/2;
}else {
//子女节点小于双亲说明该树已经为大根堆,无需向下调整,直接中断即可
break;
}
}
}
//大根堆插入元素的方法
public void maxOffer(int val){
//判满扩容
if(isFull()){
elem=Arrays.copyOf(elem,2*elem.length);
}
//将插入的元素放置在数组末端
elem[usedSize]=val;
usedSize++;
//调用到向上调整的底层方法
maxSiftUp(usedSize-1);
}
//小根堆插入元素时调用到的向上调整的底层方法
private void minSiftUp(int child){
int parent=(child-1)/2;
while(parent>=0){
//如果子女节点的值小于双亲节点的值则进行交换调整
if(elem[child]<elem[parent]){
int temp=elem[child];
elem[child]=elem[parent];
elem[parent]=temp;
//向上迭代
child=parent;
parent=(child-1)/2;
}else {
//子女节点大于双亲说明该树已经为小根堆,无需向下调整,直接中断即可
break;
}
}
}
//小根堆插入元素的方法
public void minOffer(int val){
//判满扩容
if(isFull()){
elem=Arrays.copyOf(elem,2*elem.length);
}
//将插入的元素放置在数组末端
elem[usedSize]=val;
usedSize++;
//调用到向上调整的底层方法
minSiftUp(usedSize-1);
}
//删除元素时用到的底层判空方法
private boolean isEmpty(){
return usedSize==0;
}
//大根堆删除元素的方法
public int maxPoll(){
//判空返回-1
if(isEmpty()){
return -1;
}
//将队头元素取出
int val=elem[0];
//队头与队尾元素互换
int temp=elem[0];
elem[0]=elem[usedSize-1];
elem[usedSize-1]=elem[0];
//将usedSize--使得队尾元素(交换前的队头元素)被踢出维护范围即可实现删除
usedSize--;
//此时只有完全二叉树的根节点不为大根堆,调用向下调整的方法进行调整即可
maxSiftDown(0,usedSize);
return val;
}
//小根堆删除元素的方法
public int minPoll(){
//判空返回-1
if(isEmpty()){
return -1;
}
//将队头元素取出
int val=elem[0];
//队头与队尾元素互换
int temp=elem[0];
elem[0]=elem[usedSize-1];
elem[usedSize-1]=elem[0];
//将usedSize--使得队尾元素(交换前的队头元素)被踢出维护范围即可实现删除
usedSize--;
//此时只有完全二叉树的根节点不为小根堆,调用向下调整的方法进行调整即可
minSiftDown(0,usedSize);
return val;
}
//获取队头元素的方法
public int peek(){
return elem[0];
}
//展示数组元素的方法
public void display(){
System.out.println(Arrays.toString(elem));
}
(3)堆排序方法:
//基于小根堆的从大到小的堆排序方法
public void heapSort(){
int endIndex=usedSize-1;
while(endIndex>0){
//将堆顶元素和堆尾元素交换
int temp=elem[endIndex];
elem[endIndex]=elem[0];
elem[0]=temp;
//利用小根堆向下调整的方法
minSiftDown(0,endIndex);
endIndex--;
}
}
//基于大根堆的从小到大的堆排序方法
public void heapSortReverse(){
int endIndex=usedSize-1;
while(endIndex>0){
//将堆顶元素和堆尾元素交换
int temp=elem[endIndex];
elem[endIndex]=elem[0];
elem[0]=temp;
//利用大根堆向下调整的方法
maxSiftDown(0,endIndex);
endIndex--;
}
}
本算法的主要思路是,由于堆顶元素一定为最值,所以可以利用堆的优先级特性,升序排列建大堆,降序排列建小堆,每次将堆顶元素和未排序堆尾元素互换后进行向上调整(这样堆尾元素一定是当前堆的最值),最终整个堆有序。(思路类似于冒泡排序,即每次都将未排序的部分中的最值放于末尾,如此最终整个数组有序)。
3.测试分析
Test中源码:
public class Test {
public static void main(String[] args) {
//初始化所用数组
int[]array={23,34,12,5,6,8,2,89};
//堆的初始化
MyPriorityQueue myPriorityQueueMax=new MyPriorityQueue();
myPriorityQueueMax.init(array);
//创建大根堆
myPriorityQueueMax.createMaxHeap();
myPriorityQueueMax.display();
System.out.println("********************************");
//对堆进行降序排序
myPriorityQueueMax.heapSortReverse();
myPriorityQueueMax.display();
System.out.println("********************************");
//堆的初始化
MyPriorityQueue myPriorityQueueMin=new MyPriorityQueue();
myPriorityQueueMin.init(array);
//创建小根堆
myPriorityQueueMin.createMinHeap();
myPriorityQueueMin.display();
System.out.println("********************************");
//对堆进行升序排序
myPriorityQueueMin.heapSort();
myPriorityQueueMin.display();
}
}
测试结果如下:
(注意:数组中的0未被维护,即不在usedSize范围内,不属于堆中有效元素)
假设数组中元素个数为N,则该算法的时间复杂度为O(N*log N)。
以上便是利用堆解决Top-k问题以及堆排序的全部内容,如有不当,敬请斧正!