目录
接口
优先级队列的应用场景
优先级队列的底层原理
PriorityQUeue源码分析
接口
优先级队列也是个队列,因此也是进行提供一般的接口.
普通的队列是FIFO的原则,但是优先级队列是按照优先级高低进行出对,将优先级元素最高的元素作为队头优先出队.
优先级队列的应用场景
- 医院的夜间门诊
队列元素是病人
优先级是病情的严重情况、挂号时间
- 操作系统的调度
队列元素是任务
优先级是任务类型
优先级队列的底层原理
- 使用二叉堆作为优先级队列的底层实现
- 优先级队列是比较简单的,直接在原来的二叉堆基础上进行操作即可,相应的代码如下所示:
Heap接口
public interface Heap<E> {
int size(); // 元素的数量
boolean isEmpty(); // 是否为空
void clear(); // 清空
void add(E element); // 添加元素
E get(); // 获得堆顶元素
E remove(); // 删除堆顶元素
E replace(E element); // 删除堆顶元素的同时插入一个新元素
}
AbstractHeap接口
import java.util.Comparator;
@SuppressWarnings("unchecked")
public abstract class AbstractHeap<E> implements Heap<E> {
protected int size;
protected Comparator<E> comparator;
public AbstractHeap(Comparator<E> comparator) {
this.comparator = comparator;
}
public AbstractHeap() {
this(null);
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
protected int compare(E e1, E e2) {
return comparator != null ? comparator.compare(e1, e2)
: ((Comparable<E>)e1).compareTo(e2);
}
}
BinaryHeap实现
import java.util.Comparator;
/**
* 二叉堆(最大堆)
* @author MJ Lee
*
* @param <E>
*/
@SuppressWarnings("unchecked")
public class BinaryHeap<E> extends AbstractHeap<E> {
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
public BinaryHeap(E[] elements, Comparator<E> comparator) {
super(comparator);
if (elements == null || elements.length == 0) {
this.elements = (E[]) new Object[DEFAULT_CAPACITY];
} else {
size = elements.length;
int capacity = Math.max(elements.length, DEFAULT_CAPACITY);
this.elements = (E[]) new Object[capacity];
for (int i = 0; i < elements.length; i++) {
this.elements[i] = elements[i];
}
heapify();
}
}
public BinaryHeap(E[] elements) {
this(elements, null);
}
public BinaryHeap(Comparator<E> comparator) {
this(null, comparator);
}
public BinaryHeap() {
this(null, null);
}
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
public void add(E element) {
elementNotNullCheck(element);
ensureCapacity(size + 1);
elements[size++] = element;
siftUp(size - 1);
}
public E get() {
emptyCheck();
return elements[0];
}
public E remove() {
emptyCheck();
int lastIndex = --size;
E root = elements[0];
elements[0] = elements[lastIndex];
elements[lastIndex] = null;
siftDown(0);
return root;
}
public E replace(E element) {
elementNotNullCheck(element);
E root = null;
if (size == 0) {
elements[0] = element;
size++;
} else {
root = elements[0];
elements[0] = element;
siftDown(0);
}
return root;
}
/**
* 批量建堆
*/
private void heapify() {
// 自上而下的上滤
// for (int i = 1; i < size; i++) {
// siftUp(i);
// }
// 自下而上的下滤
for (int i = (size >> 1) - 1; i >= 0; i--) {
siftDown(i);
}
}
/**
* 让index位置的元素下滤
* @param index
*/
private void siftDown(int index) {
E element = elements[index];
int half = size >> 1;
// 第一个叶子节点的索引 == 非叶子节点的数量
// index < 第一个叶子节点的索引
// 必须保证index位置是非叶子节点
while (index < half) {
// index的节点有2种情况
// 1.只有左子节点
// 2.同时有左右子节点
// 默认为左子节点跟它进行比较
int childIndex = (index << 1) + 1;
E child = elements[childIndex];
// 右子节点
int rightIndex = childIndex + 1;
// 选出左右子节点最大的那个
if (rightIndex < size && compare(elements[rightIndex], child) > 0) {
child = elements[childIndex = rightIndex];
}
if (compare(element, child) >= 0) break;
// 将子节点存放到index位置
elements[index] = child;
// 重新设置index
index = childIndex;
}
elements[index] = element;
}
/**
* 让index位置的元素上滤
* @param index
*/
private void siftUp(int index) {
// E e = elements[index];
// while (index > 0) {
// int pindex = (index - 1) >> 1;
// E p = elements[pindex];
// if (compare(e, p) <= 0) return;
//
// // 交换index、pindex位置的内容
// E tmp = elements[index];
// elements[index] = elements[pindex];
// elements[pindex] = tmp;
//
// // 重新赋值index
// index = pindex;
// }
E element = elements[index];
while (index > 0) {
int parentIndex = (index - 1) >> 1;
E parent = elements[parentIndex];
if (compare(element, parent) <= 0) break;
// 将父元素存储在index位置
elements[index] = parent;
// 重新赋值index
index = parentIndex;
}
elements[index] = element;
}
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
}
private void emptyCheck() {
if (size == 0) {
throw new IndexOutOfBoundsException("Heap is empty");
}
}
private void elementNotNullCheck(E element) {
if (element == null) {
throw new IllegalArgumentException("element must not be null");
}
}
}
优先级队列代码
import java.util.Comparator;
public class PriorityQueue<E> {
private BinaryHeap<E> heap;
public PriorityQueue(Comparator<E> comparator) {
heap = new BinaryHeap(comparator);
}
public PriorityQueue() {
this(null);
}
public int size() {
return heap.size();
}
public boolean isEmpty() {
return heap.isEmpty();
}
public void clear() {
heap.clear();
}
public void enQueue(E element) {
heap.add(element);
}
public E deQueue() {//将优先级最高的元素直接出队
return heap.remove();
}
public E front() {
return heap.get();
}
}
测试的Person类
public class Person implements Comparable<Person>{
private String name;
private int boneBreak;
public Person(String name, int boneBreak) {
this.name = name;
this.boneBreak = boneBreak;
}
/*
这里如果我们要是使用compare方法
compare(this,person)
{
return this.boneBreak - person.boneBreak;
}
*/
//这里是重写comparable
public int compareTo(Person o) {
return this.boneBreak - o.boneBreak;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", boneBreak=" + boneBreak +
'}';
}
}
main方法
public class main {
public static void main(String[] args) {
PriorityQueue<Person> queue = new PriorityQueue();
queue.enQueue(new Person("Jack",2));
queue.enQueue(new Person("Jac",3));
queue.enQueue(new Person("Ja",1));
queue.enQueue(new Person("J",4));
queue.enQueue(new Person("Jackgfhd",8));
while(!queue.isEmpty())
{
System.out.println(queue.deQueue());
}
}
}
测试结果
PriorityQUeue源码分析
java.util.PriorityQueue之中查找,即可看到原始的优先级队列的代码