JAVA队列之优先队列
来源:互联网 发布:ps3真高达无双淘宝 编辑:程序博客网 时间:2024/05/22 08:08
最近在项目开发中开发了全双工异步长连接的通讯组件,内部用到了延迟队列。而延迟队列的内部实现的存储是用到了优先队列,当时看C++的数据结构时,了解过优先队列,用的存储是二叉树的逻辑,应该叫完全二叉树,也可以叫做最大堆。
下面看一下二叉树的算法,主要看插入和删除。
二叉树顾名思义就像一棵树,每个节点下最多可以挂两个节点,如图
在优先队列中存储的方式就是 queue = {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q};
若当前节点下标为i 那么它的子节点 左侧 = 2*i+1 右侧 = 2*i +2。优先队列顾名思义,就是优先权最大的排在队列的头部,而优先权的判断是根据对象的compare方法比较获取的,保证根节点的优先级一定比子节点的优先级大。所以放入到优先队列的元素要么实现了Comparable接口,要么在创造这个优先队列时,指定一个比较器。
下面我们来看一下优先队列的构造函数
private static final int DEFAULT_INITIAL_CAPACITY = 11; private final Comparator<? super E> comparator; public PriorityQueue() { this(DEFAULT_INITIAL_CAPACITY, null); } public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) { // Note: This restriction of at least one is not actually needed, // but continues for 1.5 compatibility if (initialCapacity < 1) throw new IllegalArgumentException(); this.queue = new Object[initialCapacity]; this.comparator = comparator; }
在空构造器初始化时,数组队列的大小为11,比较器为null。这样的话,放入优先队列的对象要实现comparable接口,也可以判断队列中不能存放null元素。
现在我们来看一下往队列中添加一个对象的过程。
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; }
可以看到,优先队列中不可能存在null元素,添加元素首先把队列修改次数++,判断是否超过内部数组的长度,超过后增加数组的长度 grow(i+1)
private void grow(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError();int oldCapacity = queue.length; // Double size if small; else grow by 50% int newCapacity = ((oldCapacity < 64)? ((oldCapacity + 1) * 2): ((oldCapacity / 2) * 3)); if (newCapacity < 0) // overflow newCapacity = Integer.MAX_VALUE; if (newCapacity < minCapacity) newCapacity = minCapacity; queue = Arrays.copyOf(queue, newCapacity); }如果数组长度小于64 是按照一倍长度增长的,长度超过64,每次增长原来的百分之50,如果长度超过了int的最大值,那就设置为
Integer.MAX_VALUE,如果新的长度小于需要增长的长度,就是设置成这个长度,最后复制原来的对象到新的数组。
这样数组长度扩展了,设置size+1。如果是空的优先队列,就把新元素添加到队列头部。如果不是空,那就根据compareTo来判断新加入的元素的优先级别,那么我们来看一下siftUp方法
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; } private void siftUpUsingComparator(int k, E x) { while (k > 0) { int parent = (k - 1) >>> 1; Object e = queue[parent]; if (comparator.compare(x, (E) e) >= 0) break; queue[k] = e; k = parent; } queue[k] = x; }
如果在创建队列的时候,指定了比较工具,那么就用比较器,比较器内部实现,可以根据自己的定义的比较原则,也可以调用加入队列的元素的compareTo方法(如果实现的话),比较方法变化自行定义。
我们主要看一下没有比较器的排序方法siftUpComparable,如下图
假设数字越小,优先级别越高,K的位置是新插入元素将要放置的位置,加入插入的是 25,那么此元素的优先级别小于它的父节点的优先级,直接把25放在K的位置。假如放置的是8,优先级别最高,所以 (k-1)>>>1 获取父节点,与父节点比较,发现优先级大于父节点,把父节点的值放入K, 把K的位置设置成父节点的下标值,递归查询父节点,定位出K的位置,把新元素放入此位置。此种二叉树算法大大降低了算法复杂度。
接下来我们看一下取走队列头部元素
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; } private void siftDownUsingComparator(int k, E x) { int half = size >>> 1; while (k < half) { int child = (k << 1) + 1; Object c = queue[child]; int right = child + 1; if (right < size && comparator.compare((E) c, (E) queue[right]) > 0) c = queue[child = right]; if (comparator.compare(x, (E) c) <= 0) break; queue[k] = c; k = child; } queue[k] = x; }
如果队列之有一个元素,就弹出这个元素,设置--size的位置为null。如果不是一个元素,弹出第一个元素,获取数组最后的一个元素,开始调用siftDown(0, x);我们先来看一下图解
这样到poll掉队列头部元素后,队列长度减一,所以最后的那个元素32的位置需要设置成null,这样一来,需要填补队列的头,由于子节点一定小于等于父节点的优先级,获取父节点的子节点
int child = (k << 1) + 1; // 获取左子节点的下标
Object c = queue[child]; // 获取左子节点
int right = child + 1; // 获取右子节点的下标
但右子节点不一定存在所以下面做了一个右节点不会为null的判断,不为null的情况下,获取两个节点中优先级高的一个
if (right < size &&((Comparable<? super E>) c).compareTo((E) queue[right]) > 0){
c = queue[child = right];
}
//而下面这段代码的意思是可能出现如下图的情况
if (key.compareTo((E) c) <= 0){
break;
}
当21移到队列头部时,队列尾部的 32元素的优先级 大于68和67的优先级,可以直接把32元素放入到21的位置,直接结束循环,减少了下面空出元素的位置的重新排序算法。
用while(k<half) 因为k如果>=half 的话,此下标以下的节点无子节点,完全二叉树定义,也可以推到。
优先队列 也就这两个比较重要的方法,对于remove(Object o)方法,无非是删除中间节点后的一种先向下排序,再向上排序的过程,可以自行查看。
欢迎交流。
- JAVA队列之优先队列
- JAVA队列之优先队列
- 优先队列之二项队列(JAVA实现)
- java 之堆实现优先队列
- (十六)java多线程之优先队列PriorityBlockingQueue
- 优先队列之左式堆(JAVA实现)
- 优先队列之二叉堆(JAVA实现)
- STL之优先队列
- STL之优先队列
- 数据结构之优先队列
- C++之优先队列
- STL之优先队列
- stl 之 优先队列
- 优先队列之 二项堆
- 算法之优先队列
- STL之优先队列
- STL之优先队列
- STL之优先队列
- 153. Find Minimum in Rotated Sorted Array
- 一键生成 ios 和安卓各尺寸截屏、图标
- 动态规划详解
- 面试遇到数据库题目总结
- 按两次返回键退出程序
- JAVA队列之优先队列
- 关于登录模块的心得体会
- Codefroces #353(Div.2) Tree Construction
- 强悍的 Linux —— 强悍的 vim (二)
- Comet4J 相关
- Ubuntu 16.04 LTS的这十项新功能,每个Ubuntu用户必须要知道!
- UIPickerView的使用
- Servlet运行机制与生命周期
- 控制台里打印view的层级 在控制台里打印controller的层级 及其他技巧