【Java数据结构】用Java模拟实现堆，详解priorityQueue接口的使用

最新推荐文章于 2025-07-22 21:54:55 发布

原创最新推荐文章于 2025-07-22 21:54:55 发布 · 1.3k 阅读

105

99 ·

CC 4.0 BY-SA版权

文章标签：

#java #数据结构

数据结构专栏收录该内容

10 篇文章

订阅专栏

堆

堆的概念

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (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，否则没有右孩子

我们发现一个父节点的下标*2 + 1 就是左孩子的下标，下标*2 + 2 就是右孩子的下标。而左右孩子的（下标 - 1）/ 2 就是父节点的下标。这个结论对我们后面模拟实现堆很重要！

堆的创建

我们知道堆分大根堆和小根堆，大根堆的每一个父节点的值都比其子节点要大，小根堆的每一个父节点的值都要比其子节点要小，那么我们就可以随机给定一个数组，来创建成堆。

1. 让parent标记需要调整的节点，child标记parent的左孩子(注意：parent如果有孩子一定先是有左孩子)

2. 如果parent的左孩子存在，即:child < size，进行以下操作，直到parent的左孩子不存在

判断parent右孩子是否存在，存在找到左右孩子中最大的孩子，让child指向最大的孩子
将parent与较大的孩子child比较，如果：parent大于较大的孩子child，调整结束。否则：交换parent与较小的孩子child的值，交换完成之后，parent中大的元素向下移动，可能导致子
树不满足对的性质，因此需要继续向下调整，即parent = child；child = parent*2+1; 然后继续执行操作2。

代码实现：

首先让parent指向最后一个节点的父节点 parent = (usedSize -1 -1) / 2,然后从此节点开始比较。

    //让parent从最后的节点的父节点开始
    public void createHeap(){
        for (int parent = (this.usedSize-1-1)/2; parent >= 0; parent--) {
            shiftDown(parent,usedSize);
        }
    }
    //调整的过程
    private void shiftDown(int parent, int usedSize) {
        int child = parent*2+1;
        while(child < usedSize) {
            if (child+1 < usedSize && this.elem[child + 1] > this.elem[child]) {
                child = child + 1;
            }
            if (this.elem[parent] < this.elem[child]) {
                int tmp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = tmp;
                parent = child;
                child = parent*2+1;
            }else{
                break;
            }
        }
    }

我们以数组{ 27,15,19,18,28,34,65,49,25,37 }来测试该代码。

测试结果：

很明显调整后的结果符合大根堆了。

注意：在调整以parent为根的二叉树时，必须要满足parent的左子树和右子树已经是堆了才可以向下调整。
时间复杂度分析：最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为 $O(\log _{2}^{n})$ 。

创建堆的时间复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)：

因此创建堆的时间复杂度是 $O(N)$ 。

堆的插入和删除的模拟实现

堆的插入

堆的插入总共需要两个步骤：
1. 先将元素放入到底层空间中(注意：空间不够时需要扩容)
2. 将最后新插入的节点向上调整，直到满足堆的性质

代码实现：

    public void offer(int val){
        //空间不足时扩容
        if(this.usedSize == this.elem.length){
            this.elem = Arrays.copyOf(elem,2*elem.length);
        }
        this.elem[this.usedSize] = val;
        this.usedSize++;
        int child = this.usedSize;
        int parent = (child-1)/2;
        while(child != 0){
            if(this.elem[child] > this.elem[parent]){
                int tmp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = tmp;
                child = parent;
                parent = (child-1)/2;
            }else{
                return;
            }
        }
    }

堆的删除

注意：堆的删除一定删除的是堆顶元素。具体如下：
1. 将堆顶元素对堆中最后一个元素交换
2. 将堆中有效数据个数减少一个
3. 对堆顶元素进行向下调整

代码实现：

    public int poll(){
        int ret = this.elem[0];//保留堆顶元素，以便返回
        //将堆顶元素与最后一个元素交换
        int tmp = this.elem[0];
        this.elem[0] = this.elem[this.usedSize-1];
        this.elem[this.usedSize-1] = tmp;
        //堆中的元素数量减一
        this.usedSize--;
        //调用方法向下调整
        shiftDown(0,usedSize);
        return ret;
    }
    private void shiftDown(int parent, int usedSize) {
        int child = parent*2+1;
        while(child < usedSize) {
            if (child+1 < usedSize && this.elem[child + 1] > this.elem[child]) {
                child = child + 1;
            }
            if (this.elem[parent] < this.elem[child]) {
                int tmp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = tmp;
                parent = child;
                child = parent*2+1;
            }else{
                break;
            }
        }
    }

优先级队列

我们之前学过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，那我们就要使用优先级队列，优先级队列的底层就是堆，通过堆来实现把优先级高的元素放到堆顶，以便于优先级高的元素先出队列，在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。

注意：

1.优先级队列时优先级高的元素先出队列。
2.优先级队列的底层是通过堆来实现的。

常用接口介绍

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

关于PriorityQueue的使用要注意：

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

import java.util.PriorityQueue;

2. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出
ClassCastException异常。
3. 不能插入null对象，否则会抛出NullPointerException。
4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容。
5. 插入和删除元素的时间复杂度为 $O(\log _{^{2}}^{n})$ 。
6. PriorityQueue底层使用了堆数据结构。
7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素。

PriorityQueue接口的常用方法介绍

构造方法

有三种构造方法：

PriorityQueue()：创建一个空的优先级队列，默认容量是11
PriorityQueue(intinitialCapacity)：创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则会抛IllegalArgumentException异常
PriorityQueue(Collection<?extends E> c)：用一个集合来创建优先级队列

public class Main {
    public static void main(String[] args) {
        //创建一个空的优先级队列，默认容量是11
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>();

        //创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则会抛IllegalArgumentException异常
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(100);

        //用一个集合来创建优先级队列
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        PriorityQueue<Integer> priorityQueue3 = new PriorityQueue<>(list);
    }
}

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

常见操作：

boolean oﬀer(E e) 插入元素e，插入成功返回true，如果e对象为空，抛出NullPointerException异常
E peek() 获取优先级最高的元素，如果优先级队列为空，返回null
E poll() 移除优先级最高的元素并返回，如果优先级队列为空，返回null
int size() 获取有效元素的个数
void clear() 清空
boolean isEmpty() 检测优先级队列是否为空，空返回true

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(1);//插入元素构建优先级队列
        priorityQueue.peek();//返回队顶元素
        priorityQueue.poll();//删除队顶元素，重新构建优先级队列
        priorityQueue.size();//返回队中有效元素个数
        priorityQueue.clear();//清空优先级队列
        priorityQueue.isEmpty();//判断优先级队列是否为空
    }
}

如何使用大根堆的优先级队列

我们在使用PriorityQueue接口的时候默认在底层构建的是一个小根堆，如果当我们想用大根堆的PriorityQueue该如果操作呢？

创建一个比较器
将比较器放置于构造方法中

代码实现

//比较器
class maxCompare implements Comparator<Integer>{

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }
}
public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new maxCompare());
    }
}

我们接下来测试一下：