Introduction aux algorithmes de tri en Python
Le tri est un processus de réorganisation des éléments dans un certain ordre afin qu'un traitement approprié puisse leur être appliqué. le tri devient nécessaire car dans la plupart des cas une donnée récupérée de la source reste mal ordonnée. Pour triompher de cela, plusieurs algorithmes de tri ont été créés au fil des ans. laissez-nous discuter brièvement de certains des algorithmes de tri clés utilisés en utilisant la programmation python.
Les 6 meilleurs algorithmes de tri en Python
Voici les différents algorithmes de tri pour python:
1. Tri des bulles
Le tri à bulles fait partie des techniques de tri les plus couramment utilisées, à partir des deux premières paires d'éléments, il s'agit de trier une série d'éléments en comparant chaque paire d'éléments adjacents. ainsi, lorsqu'un ordre mal aligné est établi, un échange d'éléments a lieu. Jusqu'à ce que le dernier élément de l'ensemble d'entrées se poursuive de manière perceptible, pour optimiser l'algorithme, nous demandons de l'arrêter une fois le tri terminé. Comment pourrons-nous établir que nous avons terminé le tri? cela pourrait être déterminé lorsque tous les éléments donnés sont en ordre. Ainsi, chaque fois que des variables sont échangées, un indicateur peut être conservé pour déterminer la réexécution du processus de tri. L'indicateur doit être défini sur false lorsqu'aucun autre échange n'est nécessaire.
Code:
def bubble_Sort(array):
length = len(array)
# loop through each and every element which are keyed
# loop through each and every element which are keyed
for iterator_1 in range(length):
#loop through next element
for iterator_2 in range(0, length-iterator_1-1):
# From 0 to ni-1 the array value needs to be looped upon
# when a element greater than the next element then the collected element needs to be swapped.
if array(iterator_2) > array(iterator_2 + 1) :
array(iterator_2), array(iterator_2 + 1) = array(iterator_2 + 1), array(iterator_2) # Driver code to test above
array = (75, 34, 54, 56, 78, 1) bubble_Sort(array)
print ("Array values after sorting:")
for i in range(len(array)):
print ("%d" %array(i))
Production:
2. Tri de sélection
Le tri par sélection est parmi les techniques de tri les plus basiques. Cette technique implique de trouver l'élément le moins ou le moins de l'ensemble non trié et de positionner cet élément au début de l'ensemble non trié. En bouclant ces opérations sur tous les éléments de l'ensemble, un ensemble complètement trié peut être obtenu. L'algorithme sépare la liste de clés accrochée à deux parties différentes. La liste interne ou la liste d'abonnement ont tendance à être déjà triées, ce qui implique de générer de l'élément le plus à gauche à l'élément le plus à droite, et la sous-liste des éléments en attente à trier qui habitent le répit de la liste. Au début, la sous-liste triée n'est pas remplie et la sous-liste non triée est la liste complète des clés.
Code:
import sys
Array = (63, 75, 13, 2, 441) # loop through each and every element in the array
for element1 in range(len(Array)):
# To determine the least element in the remaining list
minimum_idx = element1
for element2 in range(element1+1, len(Array)):
if Array(minimum_idx) > Array(element2):
min_idx = element2
# swap the determined least element with the previous element in the list
Array(element1), Array(minimum_idx) = Array(minimum_idx), Array(element1) # main code
print ("Array after getting sorted by selection sort")
for i in range(len(Array)):
print("%d" %Array(i))
Production:
3. Tri par insertion
Dans le tri par insertion, le mécanisme de tri est effectué en construisant un tableau trié avec un élément à la fois. les éléments du réseau sont comparés de manière séquentielle puis réarrangés dans un ordre spécifique. Les composants du réseau sont comparés séquentiellement à chacun des éléments, puis ordonnés simultanément dans un ordre spécifique. L'analogie utilisée ici est très similaire à l'organisation d'un jeu de cartes.
Code:
def insertion_Sort(array):
# pass through 1 to len(array)
for temp_element1 in range(1, len(array)):
key = array(temp_element1) # Move elements of array(0..i-1), that are
# greater than key, to one position ahead
# of their current position
temp_element2 = temp_element1 -1
while temp_element2 >= 0 and key < array(temp_element2) :
array(temp_element2 + 1) = array(temp_element2) temp_element2 -= 1
array(temp_element2 + 1) = key
# Driver code to test above
array = (75, 34, 54, 56, 78, 1) insertion_Sort(array)
for i in range(len(array)):
print ("% d" % array(i))
Production:
4. Tri par fusion
Le tri par fusion fonctionne sur le principe de l'algorithme de division et de conquête. Ici, l'entrée donnée est épissée en deux moitiés et les moitiés épissées sont triées puis fusionnées. Dans la perception python, la fonction merge () est utilisée pour réaliser le processus de fusion. l'algorithme de tri par insertion est comme ci-dessous,
- Le tableau mentionné doit être divisé en deux parties différentes et la médiane du tableau est déterminée pour cela.
- Le tri par fusion est appliqué dans la première moitié du fractionnement.
- Ensuite, la seconde moitié est également exposée à la même chose.
- Enfin, après le tri, les moitiés séparées sont fusionnées.
Code:
def merge_Sort(array):
if len(array) >1:
mid = len(array)//2 #determining the mid of the array
divide = array(:mid) # Dividing the array elements
split = array(mid:) # splitting the array into 2 halves
merge_Sort(divide) # first half of the sorting
merge_Sort(split) # second half of the sorting
i = j = k = 0
# Copy data to temp arrayays divide() and split() while i < len(divide) and j < len(split):
if divide(i) < split(j):
array(k) = divide(i) i+=1
else:
array(k) = split(j) j+=1
k+=1
# Checking if any element was left
while i < len(divide):
array(k) = divide(i) i+=1
k+=1
while j < len(split):
array(k) = split(j) j+=1
k+=1
# Code to print the list
def printdivideist(array):
for i in range(len(array)):
print(array(i), end=" ")
print()
# driver code to test the above code
if __name__ == '__main__':
array = (12, 2, 93, 65, 76, 27) print ("Given array is", end="\n")
printdivideist(array)
merge_Sort(array)
print("Sorted array is: ", end="\n")
printdivideist(array)
Production:
5. Tri par tas
Le tri en tas est une forme de technique de tri par sélection. Cela implique de séparer l'entrée donnée en éléments triés et non triés. Ensuite, l'algorithme boucle de cette manière sur la région non triée de sorte que sur chaque boucle la plus grande valeur sera poussée dans la région triée. Ce processus se poursuivra dans tous les éléments de la région non triée.
Un tas max est créé à partir de la liste d'entrée donnée. La dernière valeur est ensuite échangée avec la première valeur à plusieurs reprises et la plage de valeurs est également diminuée d'une unité. Ce processus se déroule jusqu'à ce que la plage diminue à 1.
Code:
def heap_sort(Ordering, number, i):
largest = i # Initialize largest as root
left= 2 * i + 1 # left = 2*i + 1
right= 2 * i + 2 # right = 2*i + 2
# to verify the left child of root is greater than the root
if left< number and Ordering(i) < Ordering(left):
largest = left
# to verify the right child of root is greaterightthan the root
if right< number and Ordering(largest) < Ordering(right):
largest = right
# swap roots on neccesity
if largest != i:
Ordering(i), Ordering(largest) = Ordering(largest), Ordering(i) # swap
# Heapify the root.
heap_sort(Ordering, number, largest)
# main function for Ordering sorting
def heapSort(Ordering):
number = len(Ordering)
# max heap build process.
for i in range(number, -1, -1):
heap_sort(Ordering, number, i)
# extract of all the elements in the given heap
for i in range(number-1, 0, -1):
Ordering(i), Ordering(0) = Ordering(0), Ordering(i) # swap
heap_sort(Ordering, i, 0)
# main section of the code
Ordering = ( 12, 11, 13, 5, 6, 7, 56, 45, 67, 78, 34, 4, 33) heapSort(Ordering)
number = len(Ordering)
print ( "Sorted Ordering value is" )
for i in range( number):
print ( " %d " %Ordering(i))
Production:
6. Tri Radix
Le tri radix est une technique de tri qui progresse sans comparer les éléments saisis. Ceci est réalisé en générant un seau selon la valeur radix pour les éléments avec plus d'un chiffre impliqué, la technique est appliquée pour tous les chiffres de l'élément. Il est également appelé tri par seau. Cette technique de tri a tendance à être trop rapide dans leurs environnements adaptés.
Code:
def radix_sort(The_list, base=10):
if The_list == ():
return
def Input_factory(numeral, base):
def Input(The_list, index):
return ((The_list(index)//(base**numeral)) % base)
return Input
greatest = max(The_list)
exponent = 0
while base**exponent <= greatest:
The_list = sort_count(The_list, base - 1, Input_factory(exponent, base))
exponent = exponent + 1
return The_list
def sort_count(The_list, greatest, Input):
count = (0)*(greatest + 1)
for i in range(len(The_list)):
count(Input(The_list, i)) = count(Input(The_list, i)) + 1
# to determine the last index for each of the element
count(0) = count(0) - 1
# zero-based indexing decrement
for i in range(1, greatest + 1):
count(i) = count(i) + count(i - 1) output_value = (None)*len(The_list)
for i in range(len(The_list) - 1, -1, -1):
output_value(count(Input(The_list, i))) = The_list(i) count(Input(The_list, i)) = count(Input(The_list, i)) - 1
return output_value
The_list = input('Enter the list of (nonnegative) numbers: ').split()
The_list = (int(x) for x in The_list) sorted_list = radix_sort(The_list)
print( ' Radix oriented sorted output : ', end='')
print(sorted_list)
Production:
Conclusion
Sur une période de temps, il y avait de nombreux algorithmes conçus pour trier l'ensemble d'entrée. Ils ont été conçus avec pour devise d'obtenir une meilleure technique et une exécution optimisée dans le processus de tri. Certains des plus importants sont discutés ci-dessus. Du point de vue python, ce langage se révèle être un langage très flexible et stable pour la conception de ces algorithmes.
Articles recommandés
Ceci est un guide de tri des algorithmes en Python. Nous discutons ici de l'introduction et des 6 meilleurs algorithmes de tri en python ainsi que de son implémentation de code. Vous pouvez également consulter les articles suivants pour en savoir plus-
- Inverser le nombre en utilisant différentes manières en Python
- Différents types d'algorithmes de routage
- Types de parcelles dans Matplotlib en Python
- Top 14 Tuples en Python