JAVA实践优先队列-最小堆

前言

最小堆，以二叉树的形式存储数据，且所有的父节点均小于等于子节点。

实现

最小堆的创建存储
将一个普通二叉树结构的数组转为最小堆

中文版参考

/**
 * 优先队列-最小堆
 *
 * 最小堆特征：
 *      所有的父节点都小于等于子节点
 * 最小堆可解决的问题：
 *      寻找或插入最大最小元素，比起普通数组。无需遍历整个数组，提高效率
 *
 * 对最小堆有两种操作，元素的上浮与下沉：
 *
 * 插入元素时
 * 上浮：当新插入的元素小于其父节点，则需要与其父节点交换位置，位置交换完毕之后
 *      需要判断交换后是否小于父节点，若存在父节点，继续判断是否符合最小堆特征
 *      若符合，交换完毕
 * 删除元素时
 * 下沉：当删除某个元素后，最小堆特征已被破坏，则需要对一部分元素进行位置的交换以符合最小堆的特征
 *      当删除元素后，存在父节点[大于]子节点时，将父节点下沉。
 *      判断是否存在左右节点，若存在，两种情况：
 *          两个子节点同时大于父节点时
 *              取较小者，与父节点交换
 *          只有其中一个节点大于父节点
 *              交换小于父节点的子节点即可
 *
 * 建立堆的两种方法：
 * 上浮法
 *      每插入一个数字，就判断是否符合最小堆特征。
 *      即对每一个插入的数字使用上浮
 * 下沉法
 *      最后一层的所有叶子节点若没有父节点，肯定是不必判断的，那么
 *      令k = n/2，n为总节点个数
 *      从k号开始，k是倒数第二层的最后一个元素
 *      此时所有叶子节点有了父节点，只需判断父节点是否需要下沉
 *
 *
 */

代码实现

public class DefineBinaryTree {
    public static void main(String[] args) {
        int[] ori = new int[] {0, 99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 32,
                99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 3299, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 32,99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 3299, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 3299, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 32,99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,
                99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,399, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 91, 32, 43, 54,
                65, 6,5 ,76,76,76, 6,7 ,3,343, 2,3,232,32,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 322,3 ,23 ,23,234 ,234,23,32, 32, 54, 7, 8,32, 3232, 32};
        int[] heap1 = ori.clone();
        int[] heap2 = ori.clone();
        int[] binaryTree = new int[]{
                0, 23, 2, 5, 12, 7, 17, 25, 19, 36, 99, 22, 28, 46, 92, 1
        };
        System.out.println("下沉前两个目标位置");
        System.out.print(binaryTree[1] + " ");
        System.out.println(binaryTree[11]);
        down(binaryTree, 1);
        System.out.println("下沉前两个目标位置");
        System.out.print(binaryTree[1] + " ");
        System.out.println(binaryTree[11]);


        System.out.println("\n上浮前");
        System.out.print(binaryTree[1] + " ");
        System.out.print(binaryTree[3] + " ");
        System.out.print(binaryTree[7] + " ");
        System.out.println(binaryTree[15]);
        up(binaryTree, binaryTree.length - 1);
        System.out.println("上浮后");
        System.out.print(binaryTree[1] + " ");
        System.out.print(binaryTree[3] + " ");
        System.out.print(binaryTree[7] + " ");
        System.out.println(binaryTree[15]);

        int i;
        long start, end;
        start = System.currentTimeMillis();
        for (i = 0; i < 1000; i++) {
            upCreate(heap1);
        }
        end = System.currentTimeMillis();
        System.out.println("非排除叶子节点:" + (end - start) + "ms");
        start = System.currentTimeMillis();
        for (i = 0; i < 1000; i++) {
            downCreate(heap2);
        }
        end = System.currentTimeMillis();
        System.out.println("排除叶子节点创建堆:" + (end - start) + "ms");

    }

    public static void upCreate(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            up(arr, i);
        }
    }

    public static void downCreate(int[] arr) {
        for (int i = arr.length / 2; i >= 1; i--) {
            down(arr, i);
        }
    }

    //根据角标判断是否需要下沉
    public static void down(int[] arr, int i) {
        //记录需要交换的角标
        int t = i;
        int n = arr.length - 1;

        //左子节点
        while (true) {

            if (i * 2 <= n) {
                if (arr[i * 2] < arr[i]) {
                    t = i * 2;
                }
            }

            //右子节点
            if (i * 2 + 1 <= n) {
                if (arr[i * 2 + 1] < arr[t]) {
                    t = i * 2 + 1;
                }
            }

            if (i != t) {
                swap(arr, i, t);
                i = t;
            } else {
                break;
            }
        }
    }

    //根据角标判断是否需要上浮
    public static void up(int[] arr, int i) {
        int it = i / 2;

        while (it != 0) {
            if (arr[it] > arr[i]) {
                swap(arr, i, it);
                i = it;
                it /= 2;
            } else {
                break;
            }
        }
    }

    public static void swap(int[] arr, int x, int y) {
        int temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
}

结果

下沉前两个目标位置
23 22
下沉前两个目标位置
2 23

上浮前
2 5 25 1
上浮后
1 2 5 25
非排除叶子节点:12ms
排除叶子节点创建堆:6ms

有点疑问

不知为何将普通二叉树数据转为最小堆时，重复次数多，时间相差反而少了。
私以为是下沉操作会比上浮多得多，所以循环多了，反而时间慢了。
暂时没有想到应用场景，还不能确定具体原因。

END