优先队列的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