优先队列的Java实现(最大二叉堆)

最大二叉堆的Java实现 ：

/**
* @ADT abstract data type 抽象数据类型
* @PriorityQueue 优先队列
*
* @KeyMethod :
*   insert(enqueue) , deleteMax(extractMax,dequeue)
*
* @最大二叉堆实现核心算法（2-堆） :
*   1. 向上过滤 : 用在插入方法。将元素放在最后，通过上浮的方式确定其位置
*   2. 向下过滤 : 用在删除最大值或堆排序中。
*      1）删除最大值后，将最后一个节点置于堆顶，通过和两个子节点的最大值比较，依次下沉，确定其位置
*      2）对于堆排序，从第n/2个节点到根节点，依次向下过滤每个元素，最后得到堆。
*
* @TODO 应用扩展
*
*   1. d-堆  每个节点有d个孩子
*   2. 最大最小堆
*   3. 两个堆的合并(merge)
*   4. 左式堆(leftist heap)
*   5. 斜堆（skew heap)
*   6. 二项队列(binomial queue)
*/
public class BinaryHeap<AnyType extends Comparable<? super AnyType>> {

private static final int DEFAULT_CAPACITY = 10;

private int currentSize;

private AnyType[] array;

public BinaryHeap() {
currentSize = 0;
array = (AnyType[]) new Comparable[DEFAULT_CAPACITY];
}

public BinaryHeap(int capacity) {
currentSize = 0;
array = (AnyType[]) new Comparable[capacity];
}

/**
* 递归方式初始化
*
* @param items
*/
public BinaryHeap(AnyType[] items) {
this(items, true);
}

/**
* 采用递归方式或者迭代（循环加动态步长）方式初始化
*
* @param items
* @param useRecurse
*/
public BinaryHeap(AnyType[] items, boolean useRecurse) {
currentSize = items.length;
array = (AnyType[]) new Comparable[items.length + DEFAULT_CAPACITY];
int i = 1;
for (AnyType item : items) {
array[i++] = item;
}
if (useRecurse) {
for (i = currentSize / 2; i > 0; i--) {
percolateDownByRecurse(i);
}
} else {
for (i = currentSize / 2; i > 0; i--) {
percolateDown(i);
}
}
}

/**
* 采用递归方式
*
* @param hole
*/
private void percolateDownByRecurse(int hole) {
int childLeft = hole * 2;
if (childLeft > currentSize) {
return;
}
// 先和左节点比，再和右节点比，一下实际上是取左节点，右节点和自身节点得最大值放入自身节点，左右节点再往下比
// 更好的做法是现将左节点和右节点比较，然后选取较大的和自身节点比较。这样只递归一个分支就可以了，可以用循环实现，见percolateDown的实现
if (array[hole].compareTo(array[childLeft]) < 0) {
AnyType temp = array[hole];
array[hole] = array[childLeft];
array[childLeft] = temp;
percolateDownByRecurse(childLeft);
}
//
int childRight = childLeft + 1;
if (childRight > currentSize) {
return;
}
if (array[hole].compareTo(array[childRight]) < 0) {
AnyType temp = array[hole];
array[hole] = array[childRight];
array[childRight] = temp;
percolateDownByRecurse(childRight);
}

}

/**
* （最优解） 采用迭代（循环加动态步长）方式(下滤)
*
* @param hole
*/
private void percolateDown(int hole) {
while (hole*2 <= currentSize) {
int child = hole * 2;
// 取左右节点的最大节点的索引
if (child != currentSize && array[child + 1].compareTo(array[child]) > 0) {
child++;
}
// 过滤下沉方式确定每个元素位置
if (array[hole].compareTo(array[child]) < 0) {
AnyType temp = array[hole];
array[hole] = array[child];
array[child] = temp;
hole = child;
} else {
break;
}
}
}

public void insert(AnyType[] items) {
for (AnyType item : items) {
insert(item);
}
}

/**
* （最优解）采用迭代（循环加动态步长）的方式实现插入
*
* @param x
*/
public void insert(AnyType x) {
// 自动增长
autoEnlargeArray();
// 将新插入元素放入最后（这里只是拿到新加入的最后一个位置，把这个位置想象成洞，并没有实际放入该元素）
int hole = ++currentSize;
// 这个循环的逻辑是每次和父节点比较，如果比父节点大，将父节点放入洞中，将洞上浮到父节点位置，然后继续循环，直到根节点退出
// 这个循环的步长为动态的 hole/2
while (hole > 1) {
int parent = hole / 2;
if (x.compareTo(array[parent]) > 0) {
array[hole] = array[parent];
hole = parent;
} else {
break;
}
}
// 最后将待插入元素插入选好的洞中
array[hole] = x;
}

/**
* 采用递归的形式实现插入
*
* @param x
*/
public void insertByRecurse(AnyType x) {
autoEnlargeArray();
array[++currentSize] = x;
percolateUp(currentSize);
}

/**
* 将插入元素保持或上浮到合适位置(上滤)
* @param index
*/
private void percolateUp(int index) {
int parent = index / 2;
if (parent == 0) {
return;
}
if (array[index].compareTo(array[parent]) > 0) {
AnyType temp = array[index];
array[index] = array[parent];
array[parent] = temp;
percolateUp(parent);
}
}

public AnyType findMax() {
return array[1];
}

// extract max
public AnyType deleteMax() {
if(isEmpty()) {
return null;
}
//提出根节点元素
AnyType max= findMax();
//将最后一个元素置于根节点，并将size减一
array[1]=array[currentSize--];
//
percolateDown(1);
return max;
}

public boolean isEmpty() {
return currentSize==0;
}

public void makeEmpty() {
currentSize=0;
array=null;
}

private void autoEnlargeArray() {
if (currentSize >= array.length + 1) {
AnyType[] temp = (AnyType[]) new Comparable[array.length * 2 + 1];
for (int i = 1; i < array.length; i++) {
temp[i] = array[i];
}
array = temp;
}
}
/*
* 降低某节点优先级
* 简单设计，仅供参考，当AnyType为Integer时有效
*/
public void decreaseKey(int index,int value){
if(index>currentSize) {
return ;
}
if(array[index] instanceof Integer) {
Integer current = (Integer) array[index];
Integer now= current-value;
array[index]= (AnyType) now;
}
percolateDown(index);
}

/*
* 增加某节点优先级
* 简单设计，仅供参考，当AnyType为Integer时有效
*/
public void increaseKey(int index,int value){
if(index>currentSize) {
return ;
}
if(array[index] instanceof Integer) {
Integer current = (Integer) array[index];
Integer now= current+value;
array[index]= (AnyType) now;
}
percolateUp(index);
}

/**
* 删除某节点
* 简单设计，仅供参考，当AnyType为Integer时有效
* @param index
*/
public void delete(int index) {
increaseKey(index,Integer.MAX_VALUE/2);
deleteMax();
}

@Override
public String toString() {
String value="[";
for(int i=1;i<=currentSize;i++) {
if(i!=1) {
value+=", ";
}
value+= array[i];
}
value+="]";
return value;
}

}

测试代码 ：

import java.util.List;
import java.util.PriorityQueue;

public class BinaryHeapTest {

public static void main(String[] args) {
BinaryHeapTest test = new BinaryHeapTest();
log("----------测试插入方法开始----------");
test.testinsert();
log("----------测试插入方法结束----------");
log("----------测试数据初始化方法开始----------");
test.testInitialize();
log("----------测试数据初始化方法结束----------");
log("----------测试提取并删除最大节点方法开始----------");
test.testDeleteMax();
log("----------测试提取并删除最大节点方法结束----------");
log("----------测试调整优先级相关方法开始----------");
test.testChangeKey();
log("----------测试调整优先级相关方法结束----------");
log("----------测试Java自带优先队列PriorityQueue开始----------");
test.testJavaDefault();
log("----------测试Java自带优先队列PriorityQueue结束----------");
}

public void testinsert() {
BinaryHeap<Integer> queue1 = new BinaryHeap<>();
BinaryHeap<Integer> queue2 = new BinaryHeap<>();
int[] data = { 10, 3, 5, 12, 44, 9 };
for (int value : data) {
queue1.insert(value);
queue2.insertByRecurse(value);
}
log("循环加动态步长的插入算法 : " + queue1);
log("递归的插入算法 : " + queue2);
}

public void testInitialize() {
Integer[] data = { 10, 3, 5, 12, 44, 9 };
BinaryHeap<Integer> queue1 = new BinaryHeap<>(data, false);
BinaryHeap<Integer> queue2 = new BinaryHeap<>(data, true);
BinaryHeap<Integer> queue3 = new BinaryHeap<>();
queue3.insert(data);
log("循环加动态步长方式，先填充数组，然后将 size/2 ~ 1 的顶点元素逐一过滤下沉 : " + queue1);
log("递归方式，先填充数组，然后将 size/2 ~ 1 的顶点元素逐一过滤下沉 : " + queue2);
log("先置空数组，然后逐个插入 : " + queue3);
}

public void testDeleteMax() {
Integer[] data = { 10, 3, 5, 12, 44, 9 };
BinaryHeap<Integer> queue = new BinaryHeap<>(data, false);
log("初始堆 : " + queue);
while (!queue.isEmpty()) {
int item = queue.deleteMax();
log("当前删除的最大值 : " + item + " , 剩余堆 : " + queue);
}
}

public void testJavaDefault() {
Integer[] data = { 10, 3, 5, 12, 44, 9 };
//此默认为最小堆
PriorityQueue<Integer> queue= new PriorityQueue();
queue.addAll(List.of(data));
while (!queue.isEmpty()) {
int item = queue.poll();
log("当前删除的最小值 : " + item + " , 剩余堆 : " + queue);
}

}
public  void testChangeKey() {
Integer[] data = { 10, 3, 5, 12, 44, 9 };
BinaryHeap<Integer> queue = new BinaryHeap<>(data, false);
log("初始堆 : " + queue);
//提高最后一个元素优先级
queue.increaseKey(6, 100);
log("将最后元素(5)优先级增加100 : " + queue);
queue.decreaseKey(3, 100);
log("将第三个元素(44)优先级降低100 : " + queue);
queue.delete(2);
log("删除第三个元素(12) : " + queue);
}

public static void log(String message) {
System.out.println(message);
}
}

程序输出 ：

———-测试插入方法开始———-

循环加动态步长的插入算法 : [44, 12, 9, 3, 10, 5]

递归的插入算法 : [44, 12, 9, 3, 10, 5]

———-测试插入方法结束———-

———-测试数据初始化方法开始———-

循环加动态步长方式，先填充数组，然后将 size/2 ~ 1 的顶点元素逐一过滤下沉 : [44, 12, 9, 10, 3, 5]

递归方式，先填充数组，然后将 size/2 ~ 1 的顶点元素逐一过滤下沉 : [44, 12, 9, 3, 10, 5]

先置空数组，然后逐个插入 : [44, 12, 9, 3, 10, 5]

———-测试数据初始化方法结束———-

———-测试提取并删除最大节点方法开始———-

初始堆 : [44, 12, 9, 10, 3, 5]

当前删除的最大值 : 44 , 剩余堆 : [12, 10, 9, 5, 3]

当前删除的最大值 : 12 , 剩余堆 : [10, 5, 9, 3]

当前删除的最大值 : 10 , 剩余堆 : [9, 5, 3]

当前删除的最大值 : 9 , 剩余堆 : [5, 3]

当前删除的最大值 : 5 , 剩余堆 : [3]

当前删除的最大值 : 3 , 剩余堆 : []

———-测试提取并删除最大节点方法结束———-

———-测试调整优先级相关方法开始———-

初始堆 : [44, 12, 9, 10, 3, 5]

将最后元素(5)优先级增加100 : [105, 12, 44, 10, 3, 9]

将第三个元素(44)优先级降低100 : [105, 12, 9, 10, 3, -56]

删除第三个元素(12) : [105, 10, 9, -56, 3]

———-测试调整优先级相关方法结束———-

———-测试Java自带优先队列PriorityQueue开始———-

当前删除的最小值 : 3 , 剩余堆 : [5, 10, 9, 12, 44]

当前删除的最小值 : 5 , 剩余堆 : [9, 10, 44, 12]

当前删除的最小值 : 9 , 剩余堆 : [10, 12, 44]

当前删除的最小值 : 10 , 剩余堆 : [12, 44]

当前删除的最小值 : 12 , 剩余堆 : [44]

当前删除的最小值 : 44 , 剩余堆 : []

———-测试Java自带优先队列PriorityQueue结束———-

GitHub 源码：

https://github.com/wodong/java-learning-stack/tree/master/algorithm/src/main/java/com/guyuesoft/structure/priorityqueue

堆算法的动态可视化展示：

http://zh.visualgo.net/en/heap