¿Existe una cola prioritaria con extractos de

Hay muchas estructuras de datos que implementan la interfaz de cola de prioridad:

• Insertar: inserta un elemento en la estructura
• Get-Min: devuelve el elemento más pequeño en la estructura
• Extract-Min: elimina el elemento más pequeño de la estructura

Las estructuras de datos comunes que implementan esta interfaz son montones (min) .

Por lo general, los tiempos de ejecución (amortizados) de estas operaciones son:

• Insertar: (a veces )O ( log n $\mathcal{O}(1)$$\mathcal{O}(\log n)$
• Get-Min:$\mathcal{O}(1)$
• Extraer-Min:$\mathcal{O}(\log n)$

El montón de Fibonacci logra estos tiempos de ejecución, por ejemplo. Ahora, mi pregunta es la siguiente:

¿Existe una estructura de datos con los siguientes tiempos de ejecución (amortizados)?

• Insertar:$\mathcal{O}(\log n)$
• Get-Min:$\mathcal{O}(1)$
• Extraer-Min:$\mathcal{O}(1)$

Si podemos construir dicha estructura en tiempo dado una entrada ordenada, entonces podemos encontrar intersecciones de línea en entradas pre-ordenadas con intersecciones estrictamente más rápidas que si utilizamos las colas de prioridad 'habituales'.o ( $\mathcal{O}(n)$$o\left(\frac{n}{\log n}\right)$

Nuestra idea es utilizar árboles de separación roscados . Aparte del artículo de Wikipedia, enhebraremos los árboles para que cada nodo tenga un puntero a su sucesor en el recorrido en orden; También mantenemos un puntero al elemento más pequeño del árbol.nextstart

Es fácil ver que es posible extraer el elemento más pequeño en el (peor de los casos) tiempo : simplemente siga el puntero, elimine el mínimo y cambie el puntero al mínimo . El mínimo nunca puede tener un hijo izquierdo; si tiene un hijo correcto, lo colocamos en el lugar mínimo en el árbol. Nosotros no realizamos los árboles ensanchamiento operación splay normalmente lo haría. El resultado es un árbol de búsqueda que todavía está razonablemente equilibrado: como solo eliminamos nodos en el flanco izquierdo, sabemos que cuando el número de nodos (en un subárbol afectado) cae a aproximadamente la mitad del número original debido a eliminaciones, el (sub ) la altura del árbol se reduce en uno.$\mathcal{O}(1)$startnext

Las inserciones son posibles en tiempo amortizado; las operaciones en zig-zag (y lo que no) aquí también reequilibrarán muy bien el árbol.$\mathcal{O}(\log n)$

Este es un bosquejo aproximado en el mejor de los casos. Los créditos van para F. Weinberg, quien se quedó perplejo sobre la pregunta conmigo y nuestro asesor M. Nebel, quien mencionó los árboles de separación, sobre la única variante de árbol que no habíamos probado.

• Insertar:$\mathcal{O}(\log n)$
• Get-Min:$\mathcal{O}(1)$
• Extraer-Min:$\mathcal{O}(1)$

Tiempo amortizado

Las implementaciones simples de una cola prioritaria (por ejemplo, cualquier BST balanceada, o el binario min-montón estándar) pueden lograr estos tiempos de ejecución (amortizados) simplemente cargando el costo de Extraer-Min para insertar, y manteniendo un puntero al elemento mínimo. Por ejemplo, podría tener una función potencial que es . Luego, insertar un nuevo elemento aumenta el potencial en O ( log n ) , por lo que el costo amortizado del inserto sigue siendo O ( log n ) , pero Extract-Min () disminuye el potencial en Ω ( log n ) , por lo que el costo amortizado es solo O $cn \log n$$O(\log n)$$O(\log n)$$\Omega(\log n)$ .$O(1)$

Peor de los casos

Puede usar una estructura de datos existente en la literatura: árboles de búsqueda de dedos y simplemente mantener un puntero al elemento mínimo. Consulte esta encuesta para obtener una descripción general y el documento de 1988 de Levcopoulos y Overmars para obtener una versión implementable que satisfaga sus necesidades.

$O(1)$$O(1)$

$O(1)$

$O(1)$

A pedido, aquí está la estructura que encontré después de formular la pregunta:

La idea básica es usar un árbol de chivo expiatorio roscado junto con un puntero al mínimo (y, en buena medida, al máximo también). Una alternativa más simple al subprocesamiento es mantener punteros predecesores y sucesores en cada nodo (que es equivalente, más simple, pero tiene más sobrecarga). He venido a llamarlo un montón de chivo expiatorio , solo para darle un nombre.

Solo esta estructura básica le ofrece estas operaciones:

• $\mathcal{O}(\log n)$
• $\mathcal{O}(\log n)$
• $\mathcal{O}(1)$
• Get-Min / Max: devuelve el puntero al mínimo o al máximo.

$\mathcal{O}(\log n)$$\mathcal{O}(1)$$\mathcal{O}(\log n)$$\mathcal{O}(1)$$\mathcal{O}(1)$$\mathcal{O}(1)$

• $\mathcal{O}(1)$

Combinando esto:

• $\mathcal{O}(1)$

Puede hacer un poco más con los punteros: por ejemplo, no es difícil mantener un puntero a la mediana o alguna otra estadística de orden, por lo que puede mantener un número constante de dichos punteros si los necesita.

Algunas otras cosas:

• $n$$\mathcal{O}(n)$
• $\mathcal{O}(n)$

Y finalmente, estoy bastante seguro de que puede admitir estas operaciones, pero necesito pensar un poco más antes de saber esto con seguridad:

• $\mathcal{O}(1)$

$\epsilon$$O(1)$$\log (1/\epsilon)$$\epsilon$

$\epsilon n$

Para el artículo original, claro y bien escrito, vea Bernard Chazelle, The Soft Heap: An Approximate Priority Queue with Optimal Error Rate, Journal of the ACM, 47 (6), pp. 1012-1027, 2000 . Para una implementación y análisis alternativos que afirman ser más simples e intuitivos de SODA'09, vea Kaplan H. & Zwick U., Una implementación y análisis más simple de los montones suaves de Chazelle, 2009 .

Bien, finalmente conseguí la complejidad que estabas buscando, y lo que es mejor, lo encontré en la literatura:

La peor complejidad del caso

$\bf\mathcal{O}(1)$

$\bf\mathcal{O}(1)$

$\bf\mathcal{O}(1)$

$\bf\mathcal{O}(log\ n)$

Referencia

[3]$\mathcal{O}(1)$$\mathcal{O}(log\ n)$$\mathcal{O}(n)$

Brodal, Gerth Stølting. 'Colas de prioridad fusionables rápidas'. En Actas del 4º Taller internacional sobre algoritmos y estructuras de datos, 282–290. WADS '95. Londres, Reino Unido, Reino Unido: Springer-Verlag, 1995.

[3]: Dietz, Paul F y Rajeev Raman. 'Un árbol de búsqueda de dedo de tiempo de actualización constante'. Cartas de procesamiento de información 52, no. 3 (1994): 147-154.

Aunque esto utiliza el modelo de cálculo RAM :

Nuestra estructura de datos utiliza el modelo de máquina de acceso aleatorio (RAM) con medida de costo unitario y tamaño de palabra logarítmico;

Más recientemente, se ha proporcionado un modelo de solución de cálculo Pointer-Machine[1] .

[1]: Brodal, Gerth Stølting, George Lagogiannis, Christos Makris, Athanasios Tsakalidis y Kostas Tsichlas. 'Árboles óptimos de búsqueda de dedos en la máquina de puntero'. J. Comput. Syst. Sci. 67, no. 2 (septiembre de 2003): 381–418.

Abordar este problema manteniendo dos estructuras de datos: una matriz y un árbol binario.

$\Omega(\dfrac{\log n}{\log\log n})$$\Omega(\log n)$

$\mathcal{O}(\log n)$$\mathcal{O}(\log n)$

null$\mathcal{O}(\log n)$

$\mathcal{O}(1)$$\mathcal{O}(1)$

$\mathcal{O}(\log n)$$\mathcal{O}(1)$delete_at(idx)

1 Patrascu, Mihai y Erik D. Demaine. "Límites inferiores logarítmicos en el modelo de sonda celular". SIAM J. Comput. 35, no. 4 (abril de 2006): 932–963. doi: 10.1137 / S0097539705447256.

$O(1)$$O(\sqrt{log\text{ }log\text{ }n})$

Vea el documento de 2007: Equivalencia entre colas prioritarias y clasificación por Mikkel Thorup.

$O(n\text{ }\sqrt{log\text{ }log\text{ }n})$

Análisis

$\mathcal{o}(n\ log\ log\ n)$

$\mathcal{o}(log\ log\ n)$

$\mathcal{O}(1)$

$\mathcal{O}(n)$

$\mathcal{O}(1)$

$\mathcal{O}(1)$

Implementación

1. $\mathcal{O}(1)$
2. $\mathcal{O}(6)$$\mathcal{O}(1)$
3. $k$$\pm$ $$((k > n_{\text{size}-1}) \lor (k<n_{0}) \lor ((k<n_{i}) \land (k>n_{i+1})))$$ $\mathcal{o}(log\ log\ n)$

[1]: Andersson, Arne y Christer Mattsson. 'Búsqueda de interpolación dinámica en O (log log n) Time'. En Automata, Languages ​​and Programming, editado por Andrzej Lingas, Rolf Karlsson y Svante Carlsson, 700: 15–27. Lecture Notes in Computer Science. Springer Berlin / Heidelberg, 1993. http://dx.doi.org/10.1007/3-540-56939-1_58 .