Pila se introduce delante dentro y fuera de la nueva, y la cola FIFO es
1, la estructura de cola
interfaz pública cola <E> Colección extiende <E> {
complemento booleano (E e);
oferta booleano (E e);
E remove ();
Sondeo E ();
Elemento E ();
E peek ();
}
Queue es una interfaz.
2, análisis de código fuente PriorityQueue
PriorityQueue es una cola de prioridad, la diferencia entre la cola y FIFO son: cada uno de los elementos cola de prioridad son un equipo de los elementos de mayor prioridad . Cómo prioridad para determinar qué elementos de la misma? jdk montón usando esta estructura de datos, a través de la pila de modo que la más pequeña por cola siempre elemento, el tamaño comparación elemento especificado por Compareator quitadas de la cola, correspondiente a la prioridad.
3. ¿Cuál es el montón y montones binarias?
1) el valor de un nodo de pila es siempre mayor que o no menor que la de su nodo padre
2) Montón siempre un árbol completa
Montón escena tiene un montón binario, montón de Fibonacci y así sucesivamente. El PriorityQueue es un montón binario.
heap binario es una pila especial, montón binario es un árbol binario completo o casi completo árbol binario. Hay dos pila binaria: máximo y mínimo de pila pila
almacenamiento dinámico máximo: nodo clave de los padres es siempre mayor que o igual a cualquier tecla de un nodo hijo
circuito de espera mínimo: la clave del nodo padre es siempre menor o igual a cualquier tecla de un nodo hijo
Leyenda pila binaria
La figura es un árbol completo binario (heap binario), caracterizado por: antes de la n-ésima profundidad de la capa está llena, no empieza a llenar la profundidad de la n + 1 capa, y el elemento se inserta se llena de izquierda a derecha.
Sobre la base de esta función, montón binario y puede ser representada por una matriz en lugar de una lista enlazada. Nos fijamos en las siguiente figura muestra un montón matriz binaria
Para la matriz de n elementos de cualquier elemento, en la matriz de pila binaria base mientras que su 2n + 1 posición hijo izquierdo en el niño derecha de la posición 2n + 2 de su nodo padre en la (n-1) / 2 , mientras que el nodo raíz es una posición en un 0.
4, la estructura de datos PriorityQueue, la pila es
público de clase PriorityQueue <E> el AbstractQueue extiende <E>
los implementos de la java.io.Serializable {
// capacidad por defecto 11.
Privado final static int DEFAULT_INITIAL_CAPACITY = 11;.
// utilizar una matriz para almacenar elementos
objeto transitorio [] cola; // no -private simplificar anidada acceso a la clase
// elemento de la cola tamaño
privada int size = 0;
// cola de prioridad implementado por el comparador
privada comparador comparador final <super E?>;
}
5, el constructor
Nos fijamos en el constructor principal
PriorityQueue pública (int initialCapacity, Comparador comparador <Super E?>) {
si (initialCapacity <1)
throw new IllegalArgumentException ();
this.queue = new Object [initialCapacity];
this.comparator = comparador;
}
6, añadir el principio de un montón binario
características pila binaria:
1) el nodo padre es siempre menor que o igual a cualquier tecla una tecla nodos secundarios.
2) basado en la matriz de pila binaria implementado, para la matriz de n en cualquier elemento del elemento, su 2n + 1 posición hijo izquierdo, el hijo derecho 2n + 2 posición, su nodo padre en la (n-1) / 2, mientras que el nodo raíz es una posición en un 0.
Para mantener esta característica, una pila binaria cuando la adición de elementos, requiere una operación de "moverse hacia arriba", como se muestra en la figura.
7, la fuente de elemento analítico añadió
// añadir un elemento
pública de Boole el botón Añadir (E E) {
devolver la oferta (E);
}
public boolean la oferta (E E) {
SI (E == null)
al lanzar una NullPointerException nuevo nuevo ();
// versión modificada hecho +1
ModCount ++;
/ / registrar el número actual de elementos de cola
int i = tamaño;
// si el número actual de elementos en la mayor cola que o igual a la longitud de la matriz subyacente, para la expansión de la
IF (I> = queue.length)
Grow (I + 1.);
// elemento 1 número
size = I + 1;.
// si no hay elemento de la cola, se añadirá el elemento directamente a la raíz e
IF (I == 0)
cola [0] = e;
método // else llamadas siftUp para añadir un elemento el fallo de la cola, el cambio en
la persona
siftUp (I, E);
regreso a la verdadera;
}
1) la expansión operativo
Crecer private void (int ser minCapacity) {
int = oldCapacity queue.length;
// si la cola actual es menor que 64, la expansión a 2 veces, o 1,5 veces la expansión
int newCapacity oldCapacity + = ((oldCapacity <64)?
(2 + oldCapacity ):
(oldCapacity >> 1));.
// int si la expansión más allá de la gama, el newCapacity asignado Integer.MAX_VALUE
IF (newCapacity - MAX_ARRAY_SIZE> 0)
newCapacity = hugeCapacity (sea minCapacity);
// array para la copia de expansión
cola Arrays.copyOf = (Queue, newCapacity);
}
operación de cambio 2)
Mover //, x representa un nuevo elemento se inserta, k representa la posición recién insertada en el elemento de matriz
privada siftUp void (int K, E X) {
// desplazamiento método de operación dependiendo de si el comparador está vacío, la selección de un diferente
si ( ! = null comparador)
siftUpUsingComparator (K, X);
la otra
siftUpComparable (K, X);
}
// comparador está vacía, este método se llama operación de cambio realizado en el
privado vacío siftUpComparable (int K, E X) {
el comparable <? E super> Key = (? la comparable <super E>) x;
// 0 donde k indica la k no es juzgado root>, x es un elemento con un nodo padre.
el tiempo (K> 0) {
// calcular la posición del nodo padre del elemento x / 2 (n- 1).
int matriz = (K - 1). >>> 1;.
elemento padre de x tomada // E
objeto de cola = E [parent ];
// si el nuevo elemento es mayor que su padre elemento E k, que no es necesario para "mover", fuera de la final de ciclo
IF (key.compareTo ((E) E)> = 0)
PAUSA;
// x más pequeño que el elemento padre, la necesidad de "movimiento"
// elemento de conmutación de x y la posición de la matriz nodo e
cola de [k] = e;
iteración // nuevo elemento insertado en los puntos de nodo padre a la posición de la posición k, llevaron a cabo
parent = k;
}
asignación // encontrar la posición correcta después de que el nuevo elemento x k
cola [k] = llave;
}
Resumen: "Subir" operaciones de lixiviación binarios principalmente mantendrán los nuevos elementos y los elementos primarios para comparar, que el nodo padre es un pequeño cambio. Mover el nodo padre y luego comparar, hasta que el nodo raíz.
8, el principio de pila binaria elimina
Correspondiente a la operación de lixiviación en dequeue binario es eliminar el elemento raíz, que es el elemento más pequeño, se mueve para encontrar una posición de sustitución de la raíz, para retirar el elemento, que es el "abajo"
Referencia: https://www.cnblogs.com/linghu-java/p/9467805.html