PriorityQueue源码解析

最新推荐文章于 2022-01-14 22:53:12 发布
最新推荐文章于 2022-01-14 22:53:12 发布
阅读量108 收藏
点赞数
分类专栏： JAVA 数据结构 文章标签： Java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxk_1993/article/details/96481711
版权

转载请以链接形式标明出处：
本文出自:103style的博客

base on jdk_1.8.0_77

目录

  • PriorityQueue简介
  • PriorityQueue示例
  • PriorityQueue的常量和成员变量介绍
  • PriorityQueue的构造函数
  • PriorityQueue相关的函数
  • 小结

PriorityQueue简介

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable

A priority queue is unbounded, but has an internal capacity governing the size of an array used to store the elements on the queue.

PriorityQueue 一个基于优先级的 无界但有内部容量的(容量最大为 Integer.MAX_VALUE) 优先级队列。

优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。

该队列不允许使用 null 元素也不允许插入不可比较的对象(没有实现Comparable接口的对象)。

PriorityQueue 队列的头指排序规则最小那个元素。如果多个元素都是随机选先一个。

PriorityQueue 和 普通队列相比 只是对值进行了升序排序。

PriorityQueue 示例

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        list.add((int) (Math.random() * 100));
    }

    PriorityQueue<Integer> queue = new PriorityQueue<>();
    System.out.println("开始往PriorityQueue添加元素");
    for (int i = 0; i < list.size(); i++) {
        System.out.print("添加元素：" + list.get(i) + "--");
        queue.add(list.get(i));

        System.out.print("-- PriorityQueue中数组queue = ");
        Iterator<Integer> temp = queue.iterator();
        while (temp.hasNext()) {
            System.out.print(temp.next() + "--");
        }
        System.out.println();
    }

    System.out.println();

    System.out.println("依次poll() PriorityQueue中的元素");
    int size = queue.size();
    for (int i = 0; i < size; i++) {
        System.out.print("queue.poll() = " + queue.poll() + "-- PriorityQueue中数组queue = ");

        Iterator<Integer> temp = queue.iterator();
        while (temp.hasNext()) {
            System.out.print(temp.next() + "--");
        }
        System.out.println();
    }
}

输出结果：

开始往PriorityQueue添加元素
添加元素：80---- PriorityQueue中数组queue = 80--
添加元素：50---- PriorityQueue中数组queue = 50--80--
添加元素：77---- PriorityQueue中数组queue = 50--80--77--
添加元素：78---- PriorityQueue中数组queue = 50--78--77--80--
添加元素：78---- PriorityQueue中数组queue = 50--78--77--80--78--
添加元素：20---- PriorityQueue中数组queue = 20--78--50--80--78--77--
添加元素：41---- PriorityQueue中数组queue = 20--78--41--80--78--77--50--
添加元素：16---- PriorityQueue中数组queue = 16--20--41--78--78--77--50--80--
添加元素：23---- PriorityQueue中数组queue = 16--20--41--23--78--77--50--80--78--
添加元素：73---- PriorityQueue中数组queue = 16--20--41--23--73--77--50--80--78--78--

依次poll() PriorityQueue中的元素
queue.poll() = 16-- PriorityQueue中数组queue = 20--23--41--78--73--77--50--80--78--
queue.poll() = 20-- PriorityQueue中数组queue = 23--73--41--78--78--77--50--80--
queue.poll() = 23-- PriorityQueue中数组queue = 41--73--50--78--78--77--80--
queue.poll() = 41-- PriorityQueue中数组queue = 50--73--77--78--78--80--
queue.poll() = 50-- PriorityQueue中数组queue = 73--78--77--80--78--
queue.poll() = 73-- PriorityQueue中数组queue = 77--78--78--80--
queue.poll() = 77-- PriorityQueue中数组queue = 78--80--78--
queue.poll() = 78-- PriorityQueue中数组queue = 78--80--
queue.poll() = 78-- PriorityQueue中数组queue = 80--
queue.poll() = 80-- PriorityQueue中数组queue =

从输出结果看：每次add(E e)和poll()都会保证最小的元素在最前面。

下面我们来看下PriorityQueue的源码。

PriorityQueue的常量和成员变量介绍

//最长的数组长度  当大于该值是   数组长度为 Integer.MAX_VALUE
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//默认长度
private static final int DEFAULT_INITIAL_CAPACITY = 11;
//保存数据的数组
transient Object[] queue;
//PriorityQueue中的元素隔宿
int size;
//比较器
private final Comparator<? super E> comparator;
//修改次数
transient int modCount;

PriorityQueue的构造函数

  • 初始化 queue数组。
  • 设置比较器。
public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}
public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}
public PriorityQueue(Comparator<? super E> comparator) {
    this(DEFAULT_INITIAL_CAPACITY, comparator);
}
public PriorityQueue(int initialCapacity,
                     Comparator<? super E> comparator) {
    if (initialCapacity < 1)
        throw new IllegalArgumentException();
    this.queue = new Object[initialCapacity];
    this.comparator = comparator;
}
public PriorityQueue(Collection<? extends E> c) {
    if (c instanceof SortedSet<?>) {
        SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
        this.comparator = (Comparator<? super E>) ss.comparator();
        initElementsFromCollection(ss);
    }
    else if (c instanceof PriorityQueue<?>) {
        PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
        this.comparator = (Comparator<? super E>) pq.comparator();
        initFromPriorityQueue(pq);
    }
    else {
        this.comparator = null;
        initFromCollection(c);
    }
}
public PriorityQueue(PriorityQueue<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initFromPriorityQueue(c);
}

PriorityQueue相关的函数

//扩容函数
private void grow(int minCapacity)
private static int hugeCapacity(int minCapacity)

//数据操作函数
public boolean add(E e)
public boolean offer(E e)
public boolean remove(Object o)
public E poll()
public E element()
public E peek()
public Iterator<E> iterator()
扩容函数
  • 当数量少于 64 个的时候，每次扩容size = 2 * (size + 1);
  • 当数量不少于64时，每次扩容size = size + size / 2;
  • 当数量大于MAX_ARRAY_SIZE时，size = Integer.MAX_VALUE;
private void grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 50%
    int newCapacity = oldCapacity + ((oldCapacity < 64) ?
            (oldCapacity + 2) :
            (oldCapacity >> 1));
    // overflow-conscious code
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    queue = Arrays.copyOf(queue, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}
add(E e)，offer(E e)
  • 如果数组是空，则直接添加到第一个位置。
  • 如果数组不为空，则默认的添加位置是最后，然后通过siftUp(i, e)来保证最小的值在最前面，里面通过(k - 1) >>> 1进行二分查找：
    • 当e 大于等于 索引位置的值时key.compareTo((E) e) >= 0，则添加到最后。
    • 当e 小于 索引位置的值时，则两个元素互换位置。
public boolean add(E e) {
    return offer(e);
}
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;
    if (i == 0)
        queue[0] = e;
    else
        siftUp(i, e);
    return true;
}
private void siftUp(int k, E x) {
    if (comparator != null)
        siftUpUsingComparator(k, x);
    else
        siftUpComparable(k, x);
}
private void siftUpComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>) x;
    while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (key.compareTo((E) e) >= 0)
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = key;
}

文章开头的示例：

添加元素：80---- PriorityQueue中数组queue = 80--  
添加元素：50---- PriorityQueue中数组queue = 50--80--   
添加元素：77---- PriorityQueue中数组queue = 50--80--77--
添加元素：78---- PriorityQueue中数组queue = 50--78--77--80--
添加元素：78---- PriorityQueue中数组queue = 50--78--77--80--78--
添加元素：20---- PriorityQueue中数组queue = 20--78--50--80--78--77--
添加元素：41---- PriorityQueue中数组queue = 20--78--41--80--78--77--50--
添加元素：16---- PriorityQueue中数组queue = 16--20--41--78--78--77--50--80--
添加元素：23---- PriorityQueue中数组queue = 16--20--41--23--78--77--50--80--78--
添加元素：73---- PriorityQueue中数组queue = 16--20--41--23--73--77--50--80--78--78--

PriorityQueue add

poll()
  • 如果数组是空，则返回null。
  • 如果数组不为空，然后获取最后一个元素x，然后通过siftDown(0, x)来保证最小的值在最前面。
public E poll() {
    if (size == 0)
        return null;
    int s = --size;
    modCount++;
    E result = (E) queue[0];
    E x = (E) queue[s];
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);
    return result;
}
private void siftDown(int k, E x) {
    if (comparator != null)
        siftDownUsingComparator(k, x);
    else
        siftDownComparable(k, x);
}
private void siftDownComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>)x;
    int half = size >>> 1;        // loop while a non-leaf
    while (k < half) {
        int child = (k << 1) + 1; // assume left child is least
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
            c = queue[child = right];
        if (key.compareTo((E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = key;
}

文章开头的例子：

依次poll() PriorityQueue中的元素
queue.poll() = 16-- PriorityQueue中数组queue = 20--23--41--78--73--77--50--80--78--
queue.poll() = 20-- PriorityQueue中数组queue = 23--73--41--78--78--77--50--80--
queue.poll() = 23-- PriorityQueue中数组queue = 41--73--50--78--78--77--80--
queue.poll() = 41-- PriorityQueue中数组queue = 50--73--77--78--78--80--
queue.poll() = 50-- PriorityQueue中数组queue = 73--78--77--80--78--
queue.poll() = 73-- PriorityQueue中数组queue = 77--78--78--80--
queue.poll() = 77-- PriorityQueue中数组queue = 78--80--78--
queue.poll() = 78-- PriorityQueue中数组queue = 78--80--
queue.poll() = 78-- PriorityQueue中数组queue = 80--
queue.poll() = 80-- PriorityQueue中数组queue =
remove(Object o)

remove会根据删除元素的索引的位置来选择不同的调整数组的函数：

  • 在数组的前半段用siftDown
  • 在数组的后半段用siftUp
    因为siftDown在后半段的元素会直接返回，所以满足queue[i] == moved.
    int half = size >>> 1;
while (k < half) {..}

public boolean remove(Object o) {
    int i = indexOf(o);
    if (i == -1)
        return false;
    else {
        removeAt(i);
        return true;
    }
}
private int indexOf(Object o) {
    if (o != null) {
        for (int i = 0; i < size; i++)
            if (o.equals(queue[i]))
                return i;
    }
    return -1;
}

E removeAt(int i) {
    // assert i >= 0 && i < size;
    modCount++;
    int s = --size;
    if (s == i) // removed last element
        queue[i] = null;
    else {
        E moved = (E) queue[s];
        queue[s] = null;
        siftDown(i, moved);
        if (queue[i] == moved) {
            siftUp(i, moved);
            if (queue[i] != moved)
                return moved;
        }
    }
    return null;
}
element()，peek()
  • 直接返回首元素
public E element() {
    E x = peek();
    if (x != null)
        return x;
    else
        throw new NoSuchElementException();
}
public E peek() {
    return (size == 0) ? null : (E) queue[0];
}
iterator()

依次返回数组中的元素。

  • 我们可以看到 next()中的queue[lastRet = cursor++]，即为依次返回数组中的元素。
public Iterator<E> iterator() {
    return new Itr();
}
private final class Itr implements Iterator<E> {
    private int cursor;
    private int lastRet = -1;
    public boolean hasNext() {
        return cursor < size ||
                (forgetMeNot != null && !forgetMeNot.isEmpty());
    }
    public E next() {
        if (expectedModCount != modCount)
            throw new ConcurrentModificationException();
        if (cursor < size)
            return (E) queue[lastRet = cursor++];
        if (forgetMeNot != null) {
            lastRet = -1;
            lastRetElt = forgetMeNot.poll();
            if (lastRetElt != null)
                return lastRetElt;
        }
        throw new NoSuchElementException();
    }
    ...
}

小结

  • 每次添加删除元素的时候，会通过siftDown 或 siftUp保证最小值在最前面。
  • PriorityQueue中的queue数组不是有序的。
  • PriorityQueue的iterator()即依次返回数组queue中的元素。

以上

103style
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK源码之PriorityQueue解析
08-30
JDK源码之PriorityQueue解析 一、优先队列的应用 优先队列是程序开发中常用的数据结构之一。它可以应用于多个领域，如操作系统的进程调度、爬虫系统的任务调度等。在这些应用中，优先队列可以确保高优先级的任务或...
优先队列 PriorityQueue源码解析
weixin_43804120的博客
02-14 133
优先队列PriorityQueue源码解析
PriorityQueue优先队列源码解析
z318913的博客
01-14 296
Queue Queue是先入先出（FIFO）的一个队列数据结构，可以分为阻塞队列和非阻塞队列。 接口方法： //插入元素。成功时返回true，如果失败则抛出异常 boolean add(E e); //插入元素。成功时返回true，失败返回false boolean offer(E e); //检索并删除队列的头部，如果队列为空，则抛出异常 E remove(); //检索并删除队列的头部，如果队列为空，则返回null E poll(); //检索但不删除队列的头部，如果队列为空，则抛出异常 E eleme
STL源码——序列式容器priority_queue源码剖析
一蓑烟雨任平生
12-14 325
一、priority_queue概述 priority_queue是一种以权值进行排序的queue。由于其也是一个队列，因此也遵循先进先出（FIFO）的原则，其形式如下图所示： 特点：priority_queue会对队列中的元素根据权值进行排序（权值默认为元素的值），权值最高的在队列的头部 底层实现： SGI STL默认用一个max-heap来实现priority_queue，而max-heap又是以vector实现的complete binary tree。因此priority_queue是默认以
JDK源码研究PriorityQueue（优先队列）
JThirteen的专栏
04-19 275
Priority Queue   目的： 通过对JDK源码的分析，进一步了解堆和优先队列，体会JDK源码的优美之处。 目录：         1：概念         2：源码结构         3：方法分析 概念： 概念1：堆 堆，n个关键字序列K1，K2，…，Kn，当且仅当该序列满足如下性质称为堆 ki≤K2i且ki≤K2i+1（最小堆） 或 (2)Ki≥K2i且k...
解析Java中PriorityQueue优先级队列结构的源码及用法
09-02
在PriorityQueue的源码中，主要的成员变量有： - `private transient Object[] queue;`：存储队列元素的数组，实际实现了堆的存储。 - `private int size = 0;`：记录队列中元素的数量。 除了基本的插入和删除操作...
Java集合框架源码剖析：PriorityQueue
12-22
　前面以Java ArrayDeque为例讲解了Stack和Queue，其实还有一种特殊的队列叫做PriorityQueue，即优先队列。优先队列的作用是能保证每次取出的元素都是队列中权值小的（Java的优先队列每次取小元素，C++的优先队列...
java集合-PriorityQueue的使用
06-14
PriorityQueue是Java中的一个优先级队列，它可以根据元素的优先级对元素进行排序，并且允许高效地获取和删除最高优先级的元素。
Java的优先队列PriorityQueue原理及实例分析
08-25
Java 的优先队列 PriorityQueue 原理及实例分析 Java 的优先队列 PriorityQueue 是 Queue 接口的实现，可以对其中元素进行排序，可以放基本数据类型的包装类（如：Integer，Long 等）或自定义的类。PriorityQueue ...
PriorityQueue源码分析
ChirsPaul3的博客
05-24 190
PriorityQueue 从名字上来看，PriorityQueue叫做优先队列，它的另一个名字叫堆（heap），这个名字更熟悉。它和普通的队列不太一样，它里面存储的元素具有一定的顺序性，而不是简单的“先进先出”。它的实现原理通常是二叉堆，二叉堆是一个完全填满的二叉树。这里不做过多的介绍，都是数据结构的知识。来介绍一下优先队列的通常实现。 优先队列的整体结构虽然是一个二叉堆，也是树结构，但是存储元素的却是用数组实现的，不是通常用链表作为树的节点。因为这里隐含着一个规律，用数组的索引可以很轻松的获取它的父节点
STL-08-priority_queue源码剖析
FairLikeSnow的博客
01-31 259
priority_queue一、相关定义二、使用方法1、普通方法：2、自定义优先级：3、结构体声明方式：4、代码使用介绍三、源码剖析 一、相关定义     优先队列容器与队列一样，只能从队尾插入元素，从队首删除元素。但是它有一个特性，就是队列中最大的元素总是位于队首，所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大到小的顺序排序。元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规
PriorityQueue源码
ZHOUJIAN_TANK的博客
02-27 267
1、堆 1.1、堆的作用 1.2、堆的概念 堆首先是一颗二叉树，但他是完全二叉树 1.3、堆中添加元素 1.4、从头部删除元素 1.5、从中间删除元素 1.6、构建初始堆 1.7、遍历和查找 1.8、小结 2、PriorityQueue分析 2.1、实现原理 内部成员组成： 底层就是个数组 private static fin...
java queue-PriorityQueue源码解析
qq_41786692的博客
05-13 556
一、概念1. 它是基于优先级堆的无界优先级队列；2. 其元素是按照自然排序或者在队列构建时提供的方法来进行排序；3. 队列中不允许存在null元素；4. 它不是多线程安全的； 5. 它使用的是二叉堆，二叉堆分为大根堆和小根堆，大根堆是父节点的值总是大于或等于子节点的值，小根堆是父节点的值总是小于或等于子节点的值；6. 它总是一棵完全而查实或近似完全二叉树；7. 它内部的实现是基于数组格式的，对于数...
PriorityQueue 源码分析
xindoo
04-06 2266
学过数据结构的人应该对Queue 队列很熟悉了，队列是一种先进先出(FIFO)的数据结构，所以它出队列的优先级就是进入队列的次序。但我们有时候需要其它的优先级，很多高级语言都会提供带优先级的队列，在Java中就是PriorityQueue了，今天我们来看下PriorityQueue的使用和实现。 使用 PriorityQueue的使用很简单，如下。 public static void m...
PriorityQueue 源码解读
linhaosheng123456的博客
05-19 262
今天看了一道算法是合并k个排序链表，返回合并后得排序链表，其中有一种解法是通过PriorityQueue来实现得，所以就看下PriorityQueue得源码，了解下。 基于JDK 1.8 得源码进行分析得。 Java得PriorityQueue 实现了Queue接口，通过堆来完全二叉树来实现最小堆，所以其底层是通过数组来实现得。 ...
priorityqueue 源码解析
最新发布
03-21
下面是PriorityQueue的源码解析： 1. PriorityQueue的内部实现是一个数组，用于存储元素。它还有一个变量size，用于记录队列中元素的个数。 2. PriorityQueue可以通过构造函数指定一个Comparator来定义元素的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值