1. Descripción general de PriorityQueue
Java PriorityQueue implementa la interfaz Queue y no permite elementos nulos
- Se implementa a través de un montón, específicamente: un pequeño montón superior implementado a través de un árbol binario completo (el peso de cualquier nodo que no sea hoja no es mayor que el peso de sus nodos secundarios izquierdo y derecho), lo que significa que una matriz puede ser utilizado como PriorityQueue La implementación subyacente, el tamaño inicial de la matriz es 11; también se puede representar mediante un árbol binario completo.
- El papel de la cola de prioridad es garantizar que los elementos eliminados cada vez sean los elementos menos ponderados en la cola. La relación de tamaño está involucrada aquí. El tamaño de un elemento se puede juzgar por el orden natural del elemento mismo, o por la comparación pasada durante la construcción (Comparador, similar a un funtor de C++).
2. Resumen de métodos comunes
public boolean add(E e); //在队尾插入元素，插入失败时抛出异常，并调整堆结构
public boolean offer(E e); //在队尾插入元素，插入失败时抛出false，并调整堆结构
public E remove(); //获取队头元素并删除，并返回，失败时前者抛出异常，再调整堆结构
public E poll(); //获取队头元素并删除，并返回，失败时前者抛出null，再调整堆结构
public E element(); //返回队头元素（不删除），失败时前者抛出异常
public E peek()；//返回队头元素（不删除），失败时前者抛出null
public boolean isEmpty(); //判断队列是否为空
public int size(); //获取队列中元素个数
public void clear(); //清空队列
public boolean contains(Object o); //判断队列中是否包含指定元素（从队头到队尾遍历）
public Iterator<E> iterator(); //迭代器
3. Ajuste de la estructura del montón
Después de cada inserción o eliminación de un elemento, la cola se ajusta para que la cola siempre forme un montón mínimo (o un montón máximo).
Los ajustes específicos son los siguientes:
- Después de insertar elementos, ajuste el montón desde la parte inferior del montón hasta la parte superior del montón;
- Después de eliminar elementos, copie el elemento de cola en la cabeza y ajuste el montón desde la parte superior del montón hasta la parte inferior del montón.
Ajuste de la estructura del montón raíz pequeño:
- Después de insertar (los métodos add() y offer()) el elemento, ajuste el montón hacia arriba:
- Después de eliminar (los métodos remove() y poll()), ajuste el montón hacia abajo:
4. Uso específico
1. Implementar orden descendente
Método 1, expresión lambda
PriorityQueue<Integer> queue = new PriorityQueue<>(
(o1, o2) -> o2 - o1
);
Método 2. Reescribir el método de comparación
PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
2. Implementar clasificación personalizada
Ejemplo 1. Ordenar en orden descendente por el tercer carácter de la cadena
PriorityQueue<String> queue = new PriorityQueue<>(
(o1, o2) -> o2.charAt(2) - o1.charAt(2)
);
Ejemplo 2: personaliza una clase Personas, primero ordena por nombre, luego por edad, luego por altura
PriorityQueue<People> queue = new PriorityQueue<>(
(o1, o2) -> {
if (o1.getName().compareTo(o2.getName()) > 0) {
return 1;
} else if (o1.getName().compareTo(o2.getName()) < 0) {
return -1;
} else {
if (o1.getAge() > o2.getAge()) {
return 1;
} else if (o1.getAge() < o2.getAge()) {
return -1;
} else {
if (o1.getHeight() - o2.getHeight() > 0) {
return 1;
} else if (o1.getHeight() - o2.getHeight() < 0) {
return -1;
} else {
return 0;
}
}
}
}
);