目录
一、堆（二叉堆）
堆是用来干什么的？
在一组不断变化的（随时在添加，删除元素）集合中，快速找到 "最值" （最大值or最小值）。
堆是用什么存储结构存储的？
二叉树结构存储。假设使用线性链表结构进行维护，添加和删除的时间复杂度是O(1)，但是想找到此刻的最大值，只能进行遍历，时间复杂度为O(n)。
补充：二叉树是可以使用顺序结构进行维护的，但更适合完全二叉树。
1. 堆的概念
如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
2. 堆的性质
- 逻辑上一颗完全二叉树（不需要按照链式结构进行组织，所以没有结点的概念），而是采用顺序结构进行组织。
- 物理存储上表现为一个数组（顺序表 数字+元素个数）。
同时要求这颗完全二叉树做到：
- 大堆——同时要求这颗完全二叉树，做到任取一个树上的元素，都大于等于其两个孩子的值。
- 小堆——这颗完全二叉树，做到任取一个树上的元素，都小于等于其两个孩子的值。
注意：物理视角——根本没有结点存在！
3. 堆的存储方式
堆是一颗完全二叉树，因此可以层序的规则采用顺序的方式来高效存储。
下标之间的规则：
- 假如我们已知一个元素的下标是[k]，则这个元素的左孩子的下标一定是[2 * k + 1]，右孩子的下标一定是[2 * k + 2]。
- 假如我们已知一个元素的下标是[k]，则这个元素的双亲的下标一定是：[(k - 1) / 2]。
PS：如果这个元素是其双亲的左孩子那么双亲下标：[(k - 1) / 2]；右孩子：[(k - 2) / 2]。但是向下取整就是((k - 1) / 2)（计算机中的除法本身就是向下取整）。
语言表达上使用树的概念：根，左孩子，右孩子，叶子...但是实际代码层面都是下标的处理，数组的处理。
4. 堆的基本操作
(1). 向下调整/堆化操作
a. 前提
完全二叉树基本已经满足堆的性质，只有进行操作的元素位置和其孩子的关系还不明确（也许满足，也许不满足），只有满足这个前提，才能进行向下调整操作。
要进行向下调整操作，需要：
- 满足前提的"堆"：long[] array，int size
- 要操作的位置：int index
b. 操作（以小堆为例）
前提："我" ：待调整元素，"我" 不是叶子—>"我" 有孩子。
步骤：
1. 找到最小的孩子（可能是左孩子可能是右孩子）
2. 比较"我"和最小孩子的大小
- "我" <= 最小的孩子 —> 满足堆的性质，调整停止
- "我" > 最小的孩子 —> 交换"我"和最小的孩子
3. 交换后，条件可能满足，可能不满足，若不满足，返回上述步骤，继续交换。
最坏情况："我“是根位置，最后调整至叶子位置。
图例：
向下调整：
代码参考（小堆）：
public void shiftDown(int[] array, int parent) {
// child先标记parent的左孩子，因为parent可能右左没有右
int child = 2 * parent + 1;
int size = array.length;
while (child < size) {
// 如果右孩子存在，找到左右孩子中较小的孩子,用child进行标记
if(child+1 < size && array[child+1] < array[child]){
child += 1;
}
// 如果双亲比其最小的孩子还小，说明该结构已经满足堆的特性了
if (array[parent] <= array[child]) {
break;
}else {
// 将双亲与较小的孩子交换
int t = array[parent];
array[parent] = array[child];
array[child] = t;
// parent中大的元素往下移动，可能会造成子树不满足堆的性质，因此需要继续向下调整
parent = child;
child = parent * 2 + 1;
}
}
}c.复杂度
数据规模n是size：
- 时间复杂度：完全二叉树的高度：O(log2(n))
- 空间复杂度：非递归：O(1)；递归：O(n)
(2).堆的创建
没有任何规律的数组（完全二叉树）变成一个堆：建堆的过程。
eg：对于普通的序列{ 1,5,3,8,7,6 }，该如何调整为大堆？
代码参考：
public static void createHeap(int[] array) {
// 找倒数第一个非叶子节点，从该节点位置开始往前一直到根节点，遇到一个节点，应用向下调整
int root = ((array.length-2)>>1);
for (; root >= 0; root--) {
shiftDown(array, root);
}
}所以构造出来的大根堆为：{8，7，6，5，1，3}。
建堆的时间复杂度：O(n)
(3).堆的插入
堆的插入总共需要两个步骤：
1. 先将元素放入到底层空间中(注意：空间不够时需要扩容)；
2. 将最后新插入的节点向上调整，直到满足堆的性质。
图例（小堆）：
向上调整代码参考（大堆）：
public void shiftUp(int child) {
// 找到child的双亲
int parent = (child - 1) / 2;
while (child > 0) {
// 如果双亲比孩子大，parent满足堆的性质，调整结束
if (array[parent] > array[child]) {
break;
} else{
// 将双亲与孩子节点进行交换
int t = array[parent];
array[parent] = array[child];
array[child] = t;
// 小的元素向下移动，可能到值子树不满足对的性质，因此需要继续向上调增
child = parent;
parent = (child - 1) / 1;
}
}
}(4).堆的删除
注意：堆的删除一定删除的是堆顶元素。
具体如下：
1. 将堆顶元素对堆中最后一个元素交换
2. 将堆中有效数据个数减少一个
3. 对堆顶元素进行向下调整
图例（ 小堆）：
(5). 堆最主要的应用：优先级队列（假设小堆）
a.操作
- 插入（向上调整）
- 删除（最后一个元素放置堆顶，向下调整）
- 查看堆顶元素
b.代码实现
public class MyPriorityQueue {
// 演示作用，不再考虑扩容部分的代码
private int[] array = new int[100];
private int size = 0;
//插入
public void offer(int e) {
array[size++] = e;
shiftUp(size - 1);
}
//删除
public int poll() {
int oldValue = array[0];
array[0] = array[--size];
shiftDown(0);
return oldValue;
}
//查看堆顶元素
public int peek() {
return array[0];
}
}二、常用接口介绍
1. PriorityQueue的特性
Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，这里主要介绍PriorityQueue。
关于PriorityQueue的使用要注意：
- 使用时必须导入PriorityQueue所在的包，即：
import java.util.PriorityQueue;- PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常。
- 不能插入null对象，否则会抛出NullPointerException。
- 没有容量限制，可以插入任意多个元素，其内部可以自动扩容。
- 插入和删除元素的时间复杂度为。
- PriorityQueue底层使用了堆数据结构。
- PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素。
2.PriorityQueue常用接口介绍
(1).优先级队列的构造
这里是PriorityQueue中常见的几种构造方式，具体可以查看帮助文档。
| 构造器 | 功能介绍 |
| PriorityQueue() | 创建一个空的优先级队列，默认容量是11 |
| PriorityQueue(int initialCapacity) | 创建一个初始容量为initialCapacity的优先级队列，注意： initialCapacity不能小于1，否则会抛IllegalArgumentException异 常 |
| PriorityQueue(Collection<? extends E> c) | 用一个集合来创建优先级队列 |
如果创建一个空的优先级队列，底层默认容量是11 ，但是一般在创建优先级队列对象时，如果知道元素个数，建议就直接将底层容量给好，否则在插入时需要不断的扩容。
扩容机制：开辟更大的空间，拷贝元素，这样效率会比较低。
以下是JDK 1.8中，PriorityQueue的扩容方式：
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// overflow-conscious code
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
queue = Arrays.copyOf(queue, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}优先级队列的扩容说明：
- 如果容量小于64时，是按照oldCapacity的2倍方式扩容的
- 如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的
- 如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容
注意：默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器（实现Comparator接口，然后重写接口中的compare方法即可）。
(2).插入/删除/获取优先级最高的元素
| 函数名 | 功能介绍 |
| boolean offer(E e) | 插入元素e，插入成功返回true，如果e对象为空，抛出NullPointerException异常，时 间复杂度O(log2N) ，注意：空间不够时候会进行扩容 |
| E peek() | 获取优先级最高的元素，如果优先级队列为空，返回null |
| E poll() | 移除优先级最高的元素并返回，如果优先级队列为空，返回null |
| int size() | 获取有效元素的个数 |
| void clear() | 清空 |
| boolean isEmpty() | 检测优先级队列是否为空，空返回true |
三、堆的应用
1.PriorityQueue的实现
用堆作为底层结构封装优先级队列。
2.堆排序
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
(1).建堆
- 升序：建大堆
- 降序：建小堆
(2).利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
此外，如果想改变默认的比较方式去完成一些操作，我们可以通过实现Comparable接口或者实现Comparator接口，关于他们的具体使用可以移步：
如有建议或想法，欢迎一起讨论学习~
扫一扫
2666
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
