Python.
Créer un tas simple
Le tasifier (itérable) :- Cette fonction est utilisée pour convertir l'itérable en tas Structure de données. c'est-à-dire dans l'ordre des tas.
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)))> |
>
>Sortir
The created heap is : [1, 3, 9, 7, 5]>
Ajout et affichage d'éléments de manière efficace
- heappush(heap, ele) : Cette fonction permet d'insérer l'élément mentionné dans ses arguments dans un tas. Le l'ordre est ajusté, de sorte que la structure du tas soit conservée. heappop(heap) : Cette fonction est utilisée pour supprimer et renvoyer le plus petit élément du tas. L'ordre est ajusté afin que la structure du tas soit conservée.
Python3
parcours de vente par correspondance d'arbre binaire
# 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))> |
>
>Sortir
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>
Ajout et popping simultanément
- heappushpop(heap, ele) : - Cette fonction combine le fonctionnement des opérations push et pop en une seule instruction, augmentant ainsi l'efficacité. L'ordre du tas est maintenu après cette opération. heapreplace(heap, ele) : - Cette fonction insère et affiche également des éléments dans une seule instruction, mais elle est différente de la fonction ci-dessus. Dans ce cas, l'élément est d'abord sauté, puis l'élément est poussé. c'est-à-dire que la valeur supérieure à la valeur poussée peut être renvoyée. heapreplace() renvoie la plus petite valeur à l'origine dans le tas quel que soit l'élément poussé, par opposition à heappushpop().
Python3
# 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> ))> |
>
>Sortir
The popped item using heappushpop() is : 1 The popped item using heapreplace() is : 3>
Trouvez les éléments les plus grands et les plus petits de Heap en Python
- nlargest(k, iterable, key = fun) : Cette fonction est utilisée pour renvoyer les k plus grands éléments de l'itérable spécifié et satisfaire la clé si mentionnée. nsmallest(k, iterable, key = fun) : Cette fonction est utilisée pour renvoyer les k plus petits éléments de l'itérable spécifié et satisfaire la clé si mentionnée.
Python3
kajal aggarwal
# 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))> |
>
programme c pour tableau à deux dimensions
>Sortir
The 3 largest numbers in list are : [10, 9, 8] The 3 smallest numbers in list are : [1, 3, 4]>
Exemple:
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)> |
>
>Sortir
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]>
Ce programme crée une file d'attente de tas à l'aide du module heapq en Python et effectue diverses opérations telles que la conversion d'une liste en tas, l'ajout d'une nouvelle valeur au tas, la suppression du plus petit élément du tas, l'obtention des n éléments les plus petits et les n plus grands de le tas.
Note que le module heapq en Python fournit des fonctions permettant d'effectuer des opérations de tas sur des listes sur place, sans créer de structure de données distincte pour le tas. Le module heapq est efficace et facile à utiliser, ce qui en fait un choix populaire pour implémenter des files d'attente prioritaires et d'autres structures de données en Python.
Avantages de l'utilisation d'une file d'attente de tas (ou heapq) en Python :
- Efficace : une file d'attente de tas est une structure de données très efficace pour gérer les files d'attente prioritaires et les tas en Python. Il offre une complexité temporelle logarithmique pour de nombreuses opérations, ce qui en fait un choix populaire pour de nombreuses applications. Efficacité spatiale : les files d'attente de tas sont économes en espace, car elles stockent les éléments dans une représentation basée sur un tableau, minimisant ainsi la surcharge associée aux structures de données basées sur des nœuds telles que les listes chaînées. Facile à utiliser : les files d'attente de tas en Python sont faciles à utiliser, avec une API simple et intuitive qui facilite l'exécution d'opérations de base telles que l'insertion, la suppression et la récupération d'éléments du tas. Flexible : les files d'attente de tas en Python peuvent être utilisées pour implémenter diverses structures de données telles que des files d'attente prioritaires, des tas et des arbres binaires, ce qui en fait un outil polyvalent pour de nombreuses applications.
Inconvénients de l'utilisation d'une file d'attente de tas (ou heapq) en Python :
- Fonctionnalité limitée : les files d'attente de tas sont principalement conçues pour gérer les files d'attente et les tas prioritaires, et peuvent ne pas convenir aux structures de données et aux algorithmes plus complexes. Pas d'accès aléatoire : les files d'attente du tas ne prennent pas en charge l'accès aléatoire aux éléments, ce qui rend difficile l'accès aux éléments au milieu du tas ou la modification d'éléments qui ne sont pas en haut du tas. Pas de tri : les files d'attente de tas ne prennent pas en charge le tri, donc si vous devez trier les éléments dans un ordre spécifique, vous devrez utiliser une structure de données ou un algorithme différent. Non thread-safe : les files d'attente de tas ne sont pas thread-safe, ce qui signifie qu'elles peuvent ne pas être adaptées à une utilisation dans des applications multithread où la synchronisation des données est critique.
Dans l'ensemble, les files d'attente de tas constituent une structure de données très efficace et flexible pour gérer les files d'attente et les tas prioritaires en Python, mais peuvent avoir des fonctionnalités limitées et ne pas convenir à toutes les applications.