Úvod do triediacich algoritmov v Pythone
Triedenie je proces usporiadania prvkov v určitom poradí tak, aby sa naň mohlo použiť vhodné spracovanie. triedenie bude potrebné, pretože vo väčšine prípadov zostanú dáta získané zo zdroja zle usporiadané. Aby sa to zvíťazilo, v priebehu rokov sa vytvorilo niekoľko triediacich algoritmov. Poďme sa krátko porozprávať o niektorých kľúčových algoritmoch triedenia používaných pri programovaní v pythone.
Top 6 triediacich algoritmov v Pythone
Nižšie sú uvedené rôzne triediace algoritmy pre python:
1. Zoradenie bubliniek
Bublinové triedenie patrí medzi najbežnejšie používané techniky triedenia, počínajúc od prvých dvoch párov prvkov zahŕňa triedenie série prvkov porovnaním každej susednej dvojice prvkov. takže pri zistení nesprávneho zarovnania dôjde k výmene prvkov. Kým posledný prvok vo vstupnej množine vyššie uvedený proces nepostačuje, aby sme optimalizovali algoritmus, vyzývame ho na jeho zastavenie po dokončení triedenia. Ako možno zistíme, že sme dokončili triedenie? to by sa mohlo určiť, keď sú všetky dané položky v poriadku. Takže vždy, keď sa premenné premieňajú, môže sa udržiavať príznak na určenie opätovného vykonania procesu triedenia. Ak nie sú potrebné žiadne ďalšie swapy, mal by byť nastavený na false.
kód:
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))
Výkon:
2. Výber zoradenia
Triedenie výberu patrí medzi najzákladnejšie techniky triedenia. Táto technika zahŕňa nájdenie najmenej alebo minimálneho prvku z netriedeného súboru a umiestnenie tohto prvku na začiatok netriedeného súboru. Pri opakovaní týchto operácií vo všetkých prvkoch v súprave sa dá dosiahnuť úplne triedená množina. Algoritmus oddeľuje zoznam kľúčov závislých na dvoch rôznych častiach. Vnútorný zoznam alebo zoznam prihlásených na odber majú tendenciu byť už usporiadané, čo zahŕňa generovanie od prvku úplne doľava po prvok úplne vpravo a čiastkový zoznam nevybavených položiek, ktoré sa majú triediť a ktoré obývajú oddychovú časť zoznamu. Najprv je triedený sublista nevyplnený a netriedený sublista je kompletný zoznam kľúčov.
kód:
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))
Výkon:
3. Zoradenie vloženia
Pri zavádzaní triedenia sa triediaci mechanizmus vykonáva zostavením zoradeného poľa s jednou položkou naraz. prvky poľa sa porovnávajú postupne a potom sa usporiadajú v jednom špecifickom poradí. Komponenty poľa sa porovnávajú postupne s každým z prvkov a potom sa usporiadajú súčasne v špecifickom poradí. Použitá analógia je veľmi podobná usporiadaniu sady kariet.
kód:
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))
Výkon:
4. Zlúčiť zoradenie
Zlúčiť triedenie funguje na princípe algoritmu rozdelenia a dobývania. Tu je daný vstup zostrihaný na dve polovice a zostrihané polovice sú usporiadané a potom zlúčené. Pri vnímaní pythonu sa funkcia merge () používa na dosiahnutie procesu zlúčenia. algoritmus pre usporiadanie vloženia je uvedený nižšie,
- Uvedené pole sa musí rozdeliť na dve rôzne časti a na tento účel sa určí stred poľa.
- Zlúčiť triedenie sa použije v prvej polovici rozdelenia.
- Potom je druhá polovica tiež vystavená tomu istému.
- Nakoniec sa po triedení segregované polovice zlúčia.
kód:
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)
Výkon:
5. Usporiadanie haldy
Hromadné triedenie je forma techniky triedenia výberu. Zahŕňa to oddelenie daného vstupu ako triedené a netriedené prvky. Algoritmus sa potom slučí takým spôsobom na nevytriedenej oblasti tak, že v každej slučke bude najväčšia hodnota tlačená do triedenej oblasti. Tento proces bude pokračovať vo všetkých prvkoch netriedeného regiónu.
Z daného zoznamu vstupov sa vytvorí maximálna halda. Posledná hodnota sa potom opakovane zamení za prvú a tiež sa rozsah hodnôt pomerne zníži o jednu. Tento proces prebieha, kým sa rozsah nezmení na 1.
kód:
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))
Výkon:
6. Radix Sort
Radixovo triedenie je technika triedenia, ktorá postupuje bez porovnávania vložených prvkov. Toto sa dosahuje generovaním vedra podľa hodnoty radixu pre prvky s viac ako jednou číslicou, ktorá sa používa, technika sa uplatňuje na všetky číslice v prvku. Nazýva sa aj druh vedra. Táto technika triedenia býva v ich vhodnom prostredí príliš rýchla.
kód:
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)
Výkon:
záver
V priebehu času existovalo množstvo algoritmov určených na triedenie vstupnej sady. Boli navrhnuté s mottom dosiahnutia lepšej techniky a optimalizovaného výkonu v procese triedenia. Niektoré z najdôležitejších sú diskutované vyššie. Z hľadiska pythonu sa tento jazyk vyznačuje veľmi flexibilným a stabilným jazykom na navrhovanie týchto algoritmov.
Odporúčané články
Toto je Sprievodca triedením algoritmov v Pythone. Tu diskutujeme úvod a 6 najlepších algoritmov triedenia v pythone spolu s implementáciou kódu. Viac informácií nájdete aj v nasledujúcich článkoch
- Reverzia čísla rôznymi spôsobmi v Pythone
- Rôzne typy smerovacích algoritmov
- Typy pozemkov v Matplotlibe v Pythone
- Top 14 tuplov v Pythone