Introduzione agli algoritmi di ordinamento in Python
L'ordinamento è un processo di riorganizzazione degli elementi in un certo ordine in modo che possa essere applicato ad esso un'elaborazione adeguata. l'ordinamento diventa necessario perché nella maggior parte dei casi i dati recuperati dall'origine rimangono mal ordinati. Per trionfare su questo, nel corso degli anni sono stati creati diversi algoritmi di ordinamento. parliamo brevemente di alcuni degli algoritmi di ordinamento delle chiavi usati usando la programmazione python.
Primi 6 algoritmi di ordinamento in Python
Di seguito sono riportati i diversi algoritmi di ordinamento per Python:
1. Bubble Sort
L'ordinamento a bolle è una delle tecniche di ordinamento più comunemente utilizzate, a partire dalle prime due coppie di elementi comporta l'ordinamento di una serie di elementi confrontando ogni coppia adiacente di elementi. quindi quando viene stabilito un ordine disallineato, avviene lo scambio di elementi. Fino all'ultimo elemento nel set di input, il processo sopra descritto viene continuato in modo percettibile, per ottimizzare l'algoritmo, chiediamo di interromperlo dopo aver completato l'ordinamento. In che modo scopriremo di aver completato l'ordinamento? questo può essere determinato quando tutti gli elementi indicati sono in ordine. Quindi, ogni volta che si scambiano le variabili, è possibile mantenere un flag per determinare la riesecuzione del processo di ordinamento. Il flag deve essere impostato su false quando non sono necessari altri swap.
Codice:
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))
Produzione:
2. Selezione ordinamento
L'ordinamento per selezione è tra le tecniche di ordinamento più basiche. Questa tecnica prevede la ricerca dell'elemento minimo o minimo dell'insieme non ordinato e il posizionamento di tale elemento all'inizio dell'insieme non ordinato. Effettuando il ciclo di queste operazioni su tutti gli elementi del set è possibile ottenere un set completamente ordinato. L'algoritmo separa l'elenco di chiavi collegato a due parti diverse. L'elenco interno o l'elenco di abbonamento tendono ad essere già ordinati, il che implica la generazione dall'elemento più a sinistra all'elemento più a destra, e l'elenco secondario degli elementi in sospeso da ordinare che popolano la tregua dell'elenco. Inizialmente, l'elenco secondario ordinato non è compilato e l'elenco secondario non ordinato è l'elenco di chiavi completo.
Codice:
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))
Produzione:
3. Ordinamento inserzione
Nell'ordinamento per inserzione il meccanismo di ordinamento viene eseguito creando un array ordinato con un elemento alla volta. gli elementi dell'array vengono confrontati in modo sequenziale e quindi riorganizzati in un ordine specifico. I componenti dell'array vengono confrontati in sequenza con ciascuno degli elementi e quindi ordinati contemporaneamente in un ordine specifico. L'analogia usata qui è molto simile alla disposizione di un set di carte.
Codice:
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))
Produzione:
4. Unisci ordinamento
L'ordinamento Merge funziona in base al principio di divisione e conquista l'algoritmo. Qui l'input dato viene unito in due metà e le metà impiombate vengono ordinate e quindi unite. Nella percezione di Python, la funzione merge () viene utilizzata per raggiungere il processo di unione. l'algoritmo per l'ordinamento di inserzione è come di seguito,
- L'array menzionato deve essere diviso in due parti diverse e la mediana dell'array è determinata per questo.
- Unisci ordinamento viene applicato nella prima metà della divisione.
- Quindi anche la seconda metà è esposta alla stessa.
- Alla fine, dopo l'ordinamento, le metà separate vengono unite.
Codice:
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)
Produzione:
5. Ordinamento dell'heap
L'ordinamento heap è una forma di tecnica di ordinamento della selezione. Implica la separazione dell'input dato come elementi ordinati e non ordinati. Quindi l'algoritmo esegue un ciclo in modo tale sulla regione non ordinata in modo tale che su ogni ciclo il valore più grande venga inserito nella regione ordinata. Questo processo continuerà attraverso tutti gli elementi nella regione non ordinata.
Viene creato un heap massimo dall'elenco di input specificato. L'ultimo valore viene quindi scambiato con il primo valore ripetutamente e anche l'intervallo di valori viene diminuito comparativamente di uno. Questo processo ha luogo fino a quando l'intervallo non si riduce a 1.
Codice:
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))
Produzione:
6. Ordinamento Radix
L'ordinamento Radix è una tecnica di ordinamento che procede senza confrontare gli elementi digitati. Ciò si ottiene mediante la generazione di un bucket in base al valore radix per gli elementi con più di una cifra coinvolta, la tecnica viene applicata per tutte le cifre dell'elemento. Viene anche definito ordinamento bucket. Questa tecnica di smistamento tende ad essere troppo rapida nei loro ambienti adatti.
Codice:
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)
Produzione:
Conclusione
Nel corso di un periodo di tempo, c'erano numerosi algoritmi progettati per ordinare il set di input. Sono stati progettati con il motto di ottenere una tecnica migliore e un'esecuzione ottimizzata nel processo di selezione. Alcuni dei più importanti sono discussi sopra. Dal punto di vista di Python questo linguaggio si distingue per essere un linguaggio molto flessibile e stabile per la progettazione di questi algoritmi.
Articoli consigliati
Questa è una guida per ordinare gli algoritmi in Python. Qui discutiamo l'introduzione e i primi 6 algoritmi di ordinamento in Python insieme alla sua implementazione del codice. Puoi anche consultare i seguenti articoli per saperne di più-
- Invertire il numero usando diversi modi in Python
- Vari tipi di algoritmi di routing
- Tipi di grafici in Matplotlib in Python
- Top 14 Tuple in Python