Pitón.
Creando un montón simple
El amontonar (iterable) :- Esta función se utiliza para convertir el iterable en un montón estructura de datos. es decir, en orden de montón.
Python3
# importing 'heapq' to implement heap queue> import> heapq> # initializing list> li>=> [>5>,>7>,>9>,>1>,>3>]> # using heapify to convert list into heap> heapq.heapify(li)> # printing created heap> print> (>'The created heap is : '>,(>list>(li)))> |
alisa manonok
>
>Producción
The created heap is : [1, 3, 9, 7, 5]>
Agregar y extraer elementos de manera eficiente
- heappush(heap, ele): esta función se utiliza para insertar el elemento mencionado en sus argumentos en un montón. El El orden se ajusta para mantener la estructura del montón. heappop(heap): esta función se utiliza para eliminar y devolver el elemento más pequeño del montón. El orden se ajusta para mantener la estructura del montón.
Python3
cadena en matriz java
# importing 'heapq' to implement heap queue> import> heapq> # initializing list> li>=> [>5>,>7>,>9>,>1>,>3>]> # using heapify to convert list into heap> heapq.heapify(li)> # printing created heap> print>(>'The created heap is : '>, end>=>'')> print>(>list>(li))> # using heappush() to push elements into heap> # pushes 4> heapq.heappush(li,>4>)> # printing modified heap> print>(>'The modified heap after push is : '>, end>=>'')> print>(>list>(li))> # using heappop() to pop smallest element> print>(>'The popped and smallest element is : '>, end>=>'')> print>(heapq.heappop(li))> |
>
>Producción
The created heap is : [1, 3, 9, 7, 5] The modified heap after push is : [1, 3, 4, 7, 5, 9] The popped and smallest element is : 1>
Agregar y hacer estallar simultáneamente
- heappushpop(heap, ele): – Esta función combina el funcionamiento de las operaciones push y pop en una sola declaración, lo que aumenta la eficiencia. El orden del montón se mantiene después de esta operación. heapreplace(heap, ele): – Esta función también inserta y extrae elementos en una declaración, pero es diferente de la función anterior. En esto, primero se extrae el elemento y luego se empuja. es decir, se puede devolver el valor mayor que el valor enviado. heapreplace() devuelve el valor más pequeño originalmente en el montón independientemente del elemento insertado a diferencia de heappushpop().
Python3
hacer que el script sea ejecutable
# importing 'heapq' to implement heap queue> import> heapq> # initializing list 1> li1>=> [>5>,>1>,>9>,>4>,>3>]> # initializing list 2> li2>=> [>5>,>7>,>9>,>4>,>3>]> # using heapify() to convert list into heap> heapq.heapify(li1)> heapq.heapify(li2)> # using heappushpop() to push and pop items simultaneously> # pops 2> print>(>'The popped item using heappushpop() is : '>, end>=>'')> print>(heapq.heappushpop(li1,>2>))> # using heapreplace() to push and pop items simultaneously> # pops 3> print>(>'The popped item using heapreplace() is : '>, end>=>'')> print>(heapq.heapreplace(li2,>2>))> |
>
>Producción
The popped item using heappushpop() is : 1 The popped item using heapreplace() is : 3>
Encuentra los elementos más grandes y más pequeños de Heap en Python
- nlargest(k, iterable, key = fun): esta función se utiliza para devolver los k elementos más grandes del iterable especificado y satisfacer la clave si se menciona. nsmallest(k, iterable, key = fun): esta función se utiliza para devolver los k elementos más pequeños del iterable especificado y satisfacer la clave si se menciona.
Python3
java int como cadena
# Python code to demonstrate working of> # nlargest() and nsmallest()> # importing 'heapq' to implement heap queue> import> heapq> # initializing list> li1>=> [>6>,>7>,>9>,>4>,>3>,>5>,>8>,>10>,>1>]> # using heapify() to convert list into heap> heapq.heapify(li1)> # using nlargest to print 3 largest numbers> # prints 10, 9 and 8> print>(>'The 3 largest numbers in list are : '>, end>=>'')> print>(heapq.nlargest(>3>, li1))> # using nsmallest to print 3 smallest numbers> # prints 1, 3 and 4> print>(>'The 3 smallest numbers in list are : '>, end>=>'')> print>(heapq.nsmallest(>3>, li1))> |
>
>Producción
The 3 largest numbers in list are : [10, 9, 8] The 3 smallest numbers in list are : [1, 3, 4]>
Ejemplo:
Python3
import> heapq> # Initialize a list with some values> values>=> [>5>,>1>,>3>,>7>,>4>,>2>]> # Convert the list into a heap> heapq.heapify(values)> # Print the heap> print>(>'Heap:'>, values)> # Add a new value to the heap> heapq.heappush(values,>6>)> # Print the updated heap> print>(>'Heap after push:'>, values)> # Remove and return the smallest element from the heap> smallest>=> heapq.heappop(values)> # Print the smallest element and the updated heap> print>(>'Smallest element:'>, smallest)> print>(>'Heap after pop:'>, values)> # Get the n smallest elements from the heap> n_smallest>=> heapq.nsmallest(>3>, values)> # Print the n smallest elements> print>(>'Smallest 3 elements:'>, n_smallest)> # Get the n largest elements from the heap> n_largest>=> heapq.nlargest(>2>, values)> # Print the n largest elements> print>(>'Largest 2 elements:'>, n_largest)> |
>
>
tutorial de swing javaProducción
Heap: [1, 4, 2, 7, 5, 3] Heap after push: [1, 4, 2, 7, 5, 3, 6] Smallest element: 1 Heap after pop: [2, 4, 3, 7, 5, 6] Smallest 3 elements: [2, 3, 4] Largest 2 elements: [7, 6]>
Este programa crea una cola de montón usando el módulo heapq en Python y realiza varias operaciones, como convertir una lista en un montón, agregar un nuevo valor al montón, eliminar el elemento más pequeño del montón, obtener los n elementos más pequeños y n más grandes de el montón.
Nota que el módulo heapq en Python proporciona funciones para realizar operaciones de montón en listas en el lugar, sin crear una estructura de datos separada para el montón. El módulo heapq es eficiente y fácil de usar, lo que lo convierte en una opción popular para implementar colas de prioridad y otras estructuras de datos en Python.
Ventajas de utilizar una cola de montón (o heapq) en Python:
- Eficiente: una cola de montón es una estructura de datos altamente eficiente para gestionar colas y montones de prioridad en Python. Proporciona complejidad de tiempo logarítmico para muchas operaciones, lo que la convierte en una opción popular para muchas aplicaciones. Ahorro de espacio: las colas de montón ahorran espacio, ya que almacenan elementos en una representación basada en matrices, minimizando la sobrecarga asociada con estructuras de datos basadas en nodos, como listas vinculadas. Fácil de usar: las colas del montón en Python son fáciles de usar, con una API simple e intuitiva que facilita la realización de operaciones básicas como insertar, eliminar y recuperar elementos del montón. Flexible: las colas de montón en Python se pueden utilizar para implementar diversas estructuras de datos, como colas de prioridad, montones y árboles binarios, lo que las convierte en una herramienta versátil para muchas aplicaciones.
Desventajas de usar una cola de montón (o heapq) en Python:
- Funcionalidad limitada: las colas de montón están diseñadas principalmente para gestionar colas y montones de prioridad, y pueden no ser adecuadas para estructuras de datos y algoritmos más complejos. Sin acceso aleatorio: las colas del montón no admiten el acceso aleatorio a elementos, lo que dificulta el acceso a elementos en el medio del montón o la modificación de elementos que no están en la parte superior del montón. Sin clasificación: las colas de montón no admiten la clasificación, por lo que si necesita ordenar elementos en un orden específico, deberá utilizar una estructura de datos o un algoritmo diferente. No seguras para subprocesos: las colas de montón no son seguras para subprocesos, lo que significa que pueden no ser adecuadas para su uso en aplicaciones de subprocesos múltiples donde la sincronización de datos es fundamental.
En general, las colas de montón son una estructura de datos altamente eficiente y flexible para administrar colas de prioridad y montones en Python, pero pueden tener una funcionalidad limitada y no ser adecuadas para todas las aplicaciones.