* montón binario:
* o (log n) . Esta es la implementación más común y eficiente. Eliminar la raíz (elemento de mayor prioridad) toma O (1). Sin embargo, luego debe reemplazar la raíz con el último elemento en el montón y "acumular hacia abajo" para restaurar la propiedad del montón. Esta operación de Heapify lleva el tiempo O (log n), donde n es el número de elementos en el montón.
* Árbol de búsqueda binario (BST):
* o (log n) en el caso promedio de un BST equilibrado (como un árbol AVL o un árbol rojo-negro). Encontrar el máximo (o mínimo, dependiendo de la prioridad) es O (log n), y eliminarlo también es o (log n).
* o (n) en el peor de los casos para un BST desequilibrado. Si el árbol está sesgado (por ejemplo, se asemeja a una lista vinculada), encontrar y eliminar el máximo/mínimo puede tomar el tiempo lineal.
* Lista de matriz o vinculada (desordenado):
* o (n) . Debe iterar a través de toda la lista para encontrar el elemento con la más alta prioridad y luego eliminarlo.
* Array o lista vinculada (ordenada):
* Si se ordena por prioridad (por ejemplo, una matriz ordenada):la explotación del elemento con la más alta prioridad (probablemente al final o al principio, dependiendo del orden) puede ser O (1). Sin embargo, si está utilizando una matriz ordenada y necesita mantener el orden ordenado después de eliminar el elemento, es posible que deba cambiar elementos, lo que resulta en O (n) en el peor de los casos. Las listas vinculadas pueden evitar el cambio, por lo que el estallido es O (1) si sabe dónde está el elemento de mayor prioridad, pero encontrarlo todavía era O (n) para empezar.
* fibonacci montón:
* o (log n) tiempo amortizado. Los montones de Fibonacci son más complejos de implementar, pero ofrecen un rendimiento teóricamente mejor para ciertas operaciones, particularmente cuando tiene muchas operaciones 'disminución de llave. "Amortizado" significa que si bien las operaciones individuales pueden llevar más tiempo, la complejidad promedio de tiempo en una secuencia de operaciones es O (log N).
Resumen:
| Implementación | Complejidad del tiempo (estallido) |
| --------------------- | ----------------------- |
| Montón binario | O (log n) |
| BST equilibrado | O (log n) |
| BST desequilibrado | O (n) |
| Array/lista desordenada | O (n) |
| Matriz ordenada/lista | O (1) o o (n) |
| Fibonacci Heap | O (log n) (amortizado) |
En la práctica:
La implementación más común para las colas prioritarias es el montón binario , debido a su buen rendimiento (O (log n)) e implementación relativamente simple. Por lo tanto, generalmente puede asumir la complejidad del tiempo de aparecer de una cola de prioridad para ser o (log n) a menos que la documentación o contexto especifique explícitamente una estructura de datos subyacente diferente.