前言
优先队列是允许至少下列两种操作的数据结构：insert(插入)以及deleteMin(删除最小者)，其中deleteMin的工作是找出、返回、并删除优先队列中最小的元素。insert操作等价于enqueue(入队)，而deleteMin则相当于dequeue(出队)。
二叉堆的性质
二叉堆的使用对于优先队列的实现相当普遍。二叉堆具有结构性和堆序性：
结构性质
堆是一棵被完全填满的二叉树，有可能的例外是在底层叶子上，叶子上的元素从左到右填入。这样的树称为完全二叉树。
根据完全二叉树的性质，我们可以使用一个数组来表示而不需要使用链。该数组有一个位置0，可在进行堆的插入操作时避免多次的赋值(《数据结构forJava版》)。
对于数组中任一位置i上的元素，其左儿子在位置2i上，右儿子在左儿子后的节点(2i+1)上，它的父亲则在位置i/2上。因此，这里不需要链就可以很简单的遍历该树。
一个堆结构将由一个(Comparable对象的)数组和一个代表当前堆的大小的整数组成。
堆序性质
**在一个堆中，对于每一个节点X，X的父亲中的关键字小于或等于X中的关键字，根节点除外(它没有父亲)。**根据堆序性质我们可以很容易的得出最小的元素一定在根上，因此快速找出最小元将会是件非常容易的事，并且只需要花费常数时间。
基本的堆操作
在对堆的操作中，无外乎是需要往堆中插入元素以及删除最小元素，但是所有的操作都需要保证始终保持堆序性质。
insert插入
为了将一个元素X插入到堆中，我们需要在下一个可用位置创建一个空穴，否则该堆将不是完全树。如果X可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该空穴中，这样，空穴就朝着根的方向上冒一步。继续该过程直到X能被放入空穴中为止。
根据下图，我们想要插入14，我们在堆的下一个可用位置创建一个空穴，由于将14插入空穴破坏了堆的序(空穴父亲的关键字31大于14)，因此将31移入该空穴，空穴位置上移到原31位置，接着继续比较现在空穴与其父节点，直到找到置入14的正确位置。
堆的插入策略叫做上滤。新元素在堆中上滤直到找到正确的位置。代码也很容易实现插入。
/**
* 插入操作，需要上滤元素
* 通过不断比较空穴元素hole与其父元素的大小进行元素上滤
*/
public void insert(T item){
if(currentSize == array.length - 1){
enlargeArray(array.length * 2 + 1);
}
int hole = ++currentSize;
for(;hole > 1 && item.compareTo(array[hole/2]) < 0;hole /= 2){
array[hole] = array[hole/2];
}
array[hole] = item;
}
当进行元素插入时，由于我们是使用数组作为堆的元素存放，因此必须考虑数组越界问题，其中currentSize为数组此刻的最后一个元素的序号，当它大于数组长度时需要进行扩容。
我们通过array[hole/2]获得节点的父节点，然后来更改堆的序，确保每一个结点的父亲的关键字都要小于或等于该节点。
正常的一次交换操作需要执行三条赋值语句，如果一个元素上滤d层，那么由于交换而执行的赋值次数就达到3d，而我们这里的方法却只用到d+1次赋值。
deleteMin删除最小元
deleteMin以类似插入的方式处理。找出最小元是容易的，困难之处是删除它。当删除一个最小元时，需要在根节点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素X必须移动到该堆的某个地方。如果X可以被放到空穴中，那么deleteMin完成，不过这一般不太可能，因此我们将空穴的两个儿子中较小者移入空穴，这样空穴向下推了一层。重复该步骤直到X可以被放入空穴中。
在下图中，我们删除了该堆的最小元13，因此13位置成了空穴，所有此时需要将堆的最后一个元素31移入该空穴，但是发现该空穴的左儿子14小于该元素，因此需要将该左儿子移入空穴，并且空穴下移，反复该操作，直到31被放入正确的位置。这种一般的策略叫做下滤。
删除最小元的代码如下：
/**
* 删除最小元
* 将堆中最后一个元素放在根节点
* 然后进行元素下滤
* @return
*/
public T deleteMin(){
if (isEmpty()){
throw new NoSuchElementException();
}
T minItem = findMin();
array[1] = array[currentSize];
array[currentSize--] = null;
percolateDown(1);
return minItem;
}
/**
* 元素下滤
* 从根节点开始比较其左右儿子，找出最小的儿子与父亲进行比较
* 直到两儿子的值都大于父亲则结束循环
* 最后将根节点的值放入最小的儿子处
* @param hole
*/
public void percolateDown(int hole){
int child;
T tmp = array[hole];
for(;hole * 2 <= currentSize;hole = child){
child = hole * 2;
if(child != currentSize && array[child + 1].compareTo(array[child]) < 0){
child++;
}
if(child != currentSize && array[child].compareTo(tmp) < 0){
array[hole] = array[child];
} else {
break;
}
}
array[hole] = tmp;
}
由于我们必须保证节点不总存在两个儿子，因此在第30行我们需要对节点的儿子进行大小比较，确保下滤元素总是流向较小的一方。
完整代码
由于堆的插入和删除最小元的代码已经在上面给出，因此下面的代码段将省略这两个方法的代码。
/**
* @author: zhangocean
* @Date: 2018/10/19 13:19
* Describe:
*/
public class BinaryHeap<T extends Comparable<? super T>> {
private static final int DEFAULT_CAPACITY = 10;
private int currentSize;
private T[] array;
public BinaryHeap() {
this(DEFAULT_CAPACITY);
}
@SuppressWarnings("unchecked")
private BinaryHeap(int heapSize) {
currentSize = 0;
//不能使用泛型创建数组
array = (T[]) new Comparable[heapSize + 1];
}
@SuppressWarnings("unchecked")
public BinaryHeap(T[] items) {
currentSize = items.length;
array = (T[]) new Comparable[(currentSize + 2) * 11 / 10];
int i = 1;
for (T item : items) {
array[i++] = item;
}
buildHeap();
}
/**
* 建立堆序
* 从叶子节点中最左边的父节点开始进行元素下滤
*/
private void buildHeap() {
for (int i = currentSize / 2; i > 0; i--) {
percolateDown(i);
}
}
/**
* 插入操作，需要上滤元素
* 通过不断比较空穴元素hole与其父元素的大小进行元素上滤
*/
public void insert(T item) {
///插入代码见上方
}
/**
* 查找堆中最小的元素(即根上的元素)
*
* @return
*/
public T findMin() {
if (isEmpty()) {
return null;
}
return array[1];
}
/**
* 删除最小元
* 将堆中最后一个元素放在根节点
* 然后进行元素下滤
*
* @return
*/
public T deleteMin() {
///删除最小元代码见上方
}
/**
* 元素下滤
* 从根节点开始比较其左右儿子，找出最小的儿子与父亲进行比较
* 直到两儿子的值都大于父亲则结束循环
* 最后将根节点的值放入最小的儿子处
*
* @param hole
*/
public void percolateDown(int hole) {
///元素下滤代码见上方
}
public boolean isEmpty() {
return currentSize == 0;
}
public void makeEmpty() {
currentSize = 0;
for (int i = 0; i < array.length; i++) {
array[i] = null;
}
}
/**
* 数组扩容
*/
private void enlargeArray(int newArraySize) {
T[] oldArray = array;
array = (T[]) new Comparable[newArraySize];
int i = 0;
for (T item : oldArray) {
array[i++] = item;
}
}
public void printHeap() {
for (T item : array) {
System.out.print(item + " ");
}
System.out.println();
}
public static void main(String[] args) {
BinaryHeap<Integer> heap = new BinaryHeap<Integer>();
for (int i = 0; i < 20; i++) {
heap.insert(i);
}
heap.printHeap();
heap.deleteMin();
heap.printHeap();
heap.deleteMin();
heap.deleteMin();
heap.printHeap();
}
}
输出结果如下所示：
null 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 null null
null 1 3 2 7 4 5 6 15 8 9 10 11 12 13 14 19 16 17 18 null null null
null 3 4 5 7 9 11 6 15 8 17 10 18 12 13 14 19 16 null null null null null
总结
- 二叉堆对于优先队列的实现相对较于普遍。
- 堆需要保持堆的序，即对于堆中每个节点X，X的父亲中关键字小于或等于X中的关键字，当然啦根节点除外(它木有父亲)。
- 二叉堆是一棵完全二叉树，根据它的结构性可以用数组的方式来实现，而避免了链的使用。
- 由于是用数组来实现一棵树结构，因此需要能够对树中节点进行比较，所以通过new
Comparable数组实现数组元素之间的比较。 - 堆的主要操作在于元素插入以及删除最小元，插入时先在最后一个节点的下一个位置建立一个空穴，然后试着将需要插入的元素放入，否则上滤元素。删除最小元则是移除根节点(不用说，它肯定最小)元素，根节点成为空穴，再将最后一个结点试着移入该空穴中，否则进行元素下滤操作。
更多文章请关注我的个人博客：www.zhyocean.cn