4.2 手写Java PriorityQueue 核心源码

九路
• 阅读 1594

上一节介绍了PriorityQueue的原理,先来简单的回顾一下 PriorityQueue 的原理

以最大堆为例来介绍

  1. PriorityQueue是用一棵完全二叉树实现的。
  2. 不但是棵完全二叉树,而且树中的每个根节点都比它的左右两个孩子节点元素大
  3. PriorityQueue底层是用数组来保存这棵完全二叉树的。

如下图,是一棵最大堆。 4.2 手写Java PriorityQueue 核心源码

最大堆的删除操作 删除指的是删除根元素,也就是图中的100元素 删除元素也就是 shiftDown 操作,向下翻 删除一个根元素有以下步骤:

  1. 将100元素删除,将最后一个元素12放到100的位置上,12成为根节点
  2. 找出 12 这个节点的左右两个孩子节点中的最大的,也就是图中的28节点
  3. 12 出 28节点进行比较,如果12比28小,则交换位置
  4. 12节点继续重复2,3步骤,直到12比它的左右孩子节点都大则停止

最大堆插入一个节点 插入一个节点,也叫shiftUp操作,向上翻 以插入一个节点23为例,步骤如下:

  1. 将23放到二叉树的最后位置,也就是成为了9这个节点的左孩子
  2. 23与它的父节点进行比较,如果比它的父节点大,就交换位置
  3. 23这个节点继续重要第2步骤,直到比它的父节点小方停止比较

代码实现 首先我们先上两张图 4.2 手写Java PriorityQueue 核心源码

我们从左往右,按层序遍历,分别存放到数组的相应索引对应的位置上。 数组的第0个索引位置我们不用,从索引为1的位置开始存放。 最终这个最大堆存放到数组中,如下图 4.2 手写Java PriorityQueue 核心源码

首先实现一个最简单的只存 int 类型的优先级队列 QPriorityQueueInt 完整代码如下:

//最大堆,只存放int,并且没有扩容机制
public class QPriorityQueueInt {
    //默认底层数据大小为10
    private static int DEFAULT_INIT_CAPACITY = 10;

    //底层数组
    private int[] queue;

    //节点的个数
    private int size;

    public QPriorityQueueInt() {
        //因为数组是从索引 1 的位置开始存放,索引为 0 的位置不用
        //所以开辟空间的时候需要加 1
        queue = new int[DEFAULT_INIT_CAPACITY + 1];

        //当前数组中节点的个数为0
        size = 0;
    }

    //返回节点的个数
    public int size() {
        return size;
    }

    //最大堆是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //添加一个节点
    public void add(int e) {
        //将元素存放到数组当前最后一个位置上
        queue[size + 1] = e;

        //个数需要加1
        size++;

        //需要向上翻
        shiftUp(size);
    }

    //向上翻,最大堆中的最后一个节点,不停的与父节点比较
    //最大堆中父节点的索引是 k / 2
    private void shiftUp(int k) {
        // k > 1 ,说明从第2个节点开始,因为如果只有一个节点的话,不需要比较了
        // queue[k] > queue[k / 2] ,当前节点大于父节点
        while (k > 1 && queue[k] > queue[k / 2]) {
            //交换位置
            swap(k, k / 2);

            //把父节点的索引赋值给 k,然后继续重复上面步骤
            k = k / 2;
        }
    }

    //删除最大堆中的节点
    public int poll() {

        //把第1个位置的节点保存起来
        int result = queue[1];

        //把最后一个节点放到第1个节点上面,成为整棵树的根节点
        queue[1] = queue[size];

        //别忘了size 要减1
        size--;

        //最后一个节点成为根节点后,就需要向下翻了
        //向下翻的目的就是把大的节点翻上来
        shiftDown(1);

        //返回第1个节点,也就是队头节点
        return result;
    }


    //向下翻
    private void shiftDown(int k) {
        //2 * k <= size ,2*k 是左孩子
        //2 * k <= size ,是当前节点有左孩子
        //至少有个左孩子才可以交换,因为是完全二叉树,左孩子没有,右孩子肯定没有
        while (2 * k <= size) {

            //比较左右两个孩子节点,将大的节点的索引赋值给 j

            //左孩子索引
            int j = 2 * k;
            //如果有右孩子,且 右孩子大于左孩子,将右孩子索引赋值给j
            if (j + 1 <= size && queue[j + 1] > queue[j]) {
                j = j + 1;
            }

            //现在 j 保存的是左右孩子中较大的节点的索引
            //比较当前节点和左右孩子中较大的节点
            //如果比左右孩子中较大的节点还大,则不用向下翻了
            if (queue[k] > queue[j]) {
                break;
            }

            //否则交换当前节点和左右孩子中较大的节点
            swap(k, j);

            //把左右孩子中较大的节点的索引赋值给k,继续向下翻
            k = j;
        }
    }

    //交换两个位置
    private void swap(int i, int j) {
        int t = queue[i];
        queue[i] = queue[j];
        queue[j] = t;
    }

}

下面是测试代码:

public static void main(String[] args) {
    QPriorityQueueInt queue = new QPriorityQueueInt();

    //随便弄5个数入队,数越大优先级越大
    //由于我们的QPriorityQueueInt默认只支持10个元素
    //所以插入的节点个数不要多于10个
    queue.add(3);
    queue.add(5);
    queue.add(1);
    queue.add(8);
    queue.add(7);

    //打印
    System.out.println(queue.poll());
    System.out.println(queue.poll());
    System.out.println(queue.poll());
    System.out.println(queue.poll());
    System.out.println(queue.poll());
}

输出如下:

8
7
5
3
1

从输出可以看出来,虽然7是最后入队的,但是优先级比较高,第二次就打印出来了。 优先级队列,同样是用数组实现。但是入队的效率比单纯的用数组排序要高多了。

至于扩容机制,读者可以自己查阅相关资源,自己实现。

点赞
收藏
评论区
推荐文章
blmius blmius
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
白茶清欢 白茶清欢
3年前
js实现二叉树、二叉查找树
树是一种数据结构,该章节讨论二叉树(二叉树的每个节点的子节点不允许超过两个),二叉树中有又分为完全二叉树和不完全二叉树.....不在本章节赘述相关概念,感兴趣可以去查阅《数据结构》。你将会获得:1.如何使用js实现二叉查找树。2.学会前、中、后序遍历。3.了解相关实现原理阅读时长5min,可选择直接调试代码特点    二叉查找树中序遍历后
九路 九路
4年前
1 手写ArrayList核心源码
手写ArrayList核心源码ArrayList是Java中常用的数据结构,不光有ArrayList,还有LinkedList,HashMap,LinkedHashMap,HashSet,Queue,PriorityQueue等等,我们将手写这些常用的数据结构的核心源码,用尽量少的代码来揭示核心原理。下面我们来手写ArrayList的核心源码首先
待兔 待兔
3个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
zhenghaoz zhenghaoz
3年前
算法笔记:红黑树
红黑树,一种平衡二叉树,最为著名的应用就是CSTL中的map,是有序集合最为理想的存储方式之一。除了二叉树所具有的属性之后,红黑树中每个节点多了一个“颜色”属性,可以是红色或者是黑色。一棵红黑树应该满足一下的性质:1.每个节点是红色或者黑色的;2.根节点是黑色的;3.每个叶节点nil是黑色的(使用哨兵节点在删除调整时可以方便不少);4.如
Wesley13 Wesley13
3年前
JAVA递归实现线索化二叉树
JAVA递归实现线索化二叉树基础理论首先,二叉树递归遍历分为先序遍历、中序遍历和后序遍历。先序遍历为:根节点左子树右子树中序遍历为:左子树根节点右子树后序遍历为:左子树右子树根节点(只要记住根节点在哪里就是什么遍历,且都是先左再右)线索化现在有这么一棵二叉树,它的数据结
Wesley13 Wesley13
3年前
PHP数据结构与算法:二叉树
一、定义二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”(leftsubtree)和“右子树”(rightsubtree)。二、特性1.在二叉树的第i层上至多有2^(i1)个结点(i0)2.深度为k的二叉树至多有2^k1个结点(k0)3.对于任意一棵二叉树,如果其叶结点数为N0,而
Stella981 Stella981
3年前
LeetCode(110):平衡二叉树
Easy!题目描述:给定一个二叉树,判断它是否是高度平衡的二叉树。本题中,一棵高度平衡二叉树定义为:一个二叉树_每个节点_的左右两个子树的高度差的绝对值不超过1。示例1:给定二叉树 3,9,20,null,null,15,73/\920/
菜园前端 菜园前端
1年前
什么是二叉树?
原文链接:什么是二叉树?树中每个节点最多只能有两个子节点,在JavaScript中一般都是通过Object来模拟二叉树。常用操作前序遍历中序遍历后序遍历前序遍历根左右。口诀:1.访问根节点2.对根节点的左子树进行前序遍历3.对根节点的右子树进行前序遍历通过
菜园前端 菜园前端
1年前
什么是堆?
原文链接:什么是堆?堆是一种特殊的完全二叉树。完全二叉树的含义就是每层节点都完全填满,除了最后一层外只允许最右边缺少若干个节点。在JavaScript中通常用数组表示堆(按照广度优先遍历顺序)。最大堆最小堆特性所有的节点都大于等于它的子节点(最大堆)或者所