* `agregar (e e)` / `oferta (e e)` (inserción): O (log n):esto se debe a que la cola prioritaria debe mantener su propiedad de montón, lo que requiere tamizar el nuevo elemento hacia arriba o hacia abajo del montón.
* `remove ()` / `encis ()` (eliminación del elemento de prioridad más alta): O (log n):eliminar el elemento raíz (más alta prioridad) requiere reemplazarlo con el último elemento y luego tamizar el elemento de reemplazo hacia abajo el montón para restaurar la propiedad del montón.
* `peek ()` (accediendo al elemento de mayor prioridad): O (1) - Refirmar en el elemento de mayor prioridad (la raíz del montón) es una operación de acceso directo.
* `contiene (objeto o)`: O (n):esto requiere iterarse a través de los elementos de la cola para verificar la igualdad. Priorityqueues en Java no proporcionan una forma eficiente de verificar la contención.
* `eliminar (objeto o)`: O (n) - Similar a `contiene ()`, esto implica iterarse a través de los elementos para encontrar y eliminar el objeto especificado. Después de eliminar el objeto, se debe mantener la propiedad del montón, lo que, en el peor de los casos, puede tomar O (n) tiempo. (Eliminar un elemento arbitrario no es una operación de cola prioritaria estándar, y el rendimiento refleja esto).
* `size ()`: O (1) - El tamaño se mantiene como una variable miembro, por lo que acceder a ella es una operación de tiempo constante.
* `isEtimty ()`: O (1) - Simplemente verifica si el tamaño es 0.
* `clear ()`: O (N) - Elimina todos los elementos de la cola. Mientras que la eliminación de elementos individuales puede tomar O (log n), la eliminación de toda la cola toma O (n). En algunas implementaciones, esto en realidad puede implementarse como O (1), simplemente restableciendo la matriz y el tamaño internos.
* `iterator ()`: O (1) - Devuelve un iterador para la cola de prioridad. El iterador en sí está * no * ordenado, y iterando a través de los elementos será o (n).
Consideraciones importantes:
* `priorityqueue` se implementa como un montón binario La estructura de datos del montón es lo que le da su rendimiento logarítmico para la inserción y eliminación del elemento de mayor prioridad.
* El comparador es crucial. El comparador (o el orden natural de los elementos si no se proporciona un comparador) es lo que determina la prioridad de los elementos. El método `comparador ()` del comparador debe ser eficiente (típicamente o (1)) para las operaciones de cola de prioridad general para mantener su complejidad declarada.
* Eliminar elementos arbitrarios (`eliminar (objeto O)`) es ineficiente. Si con frecuencia necesita eliminar elementos arbitrarios de una cola de prioridad, considere usar una estructura de datos diferente o una combinación de estructuras de datos (por ejemplo, un `` treeset` combinado con un 'hashmap` para rastrear las posiciones de los elementos). Las colas de prioridad estándar están optimizadas para un acceso eficiente al elemento de mayor prioridad.
En resumen:
Las operaciones clave de `add ()` y `remove ()` (del elemento prioritario * más alto *) son O (log n), lo que hace que 'priorityqueue' sea una opción muy eficiente para escenarios en los que necesita mantener una colección ordenada y acceder repetidamente o eliminar el elemento mínimo (o máximo, dependiendo de su comparador).