堆（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问题以及堆排序的全部内容，如有不当，敬请斧正！
4056
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
