Úvod do třídění algoritmů v Pythonu
Třídění je proces přeuspořádání prvků v určitém pořadí tak, aby na něj bylo možné aplikovat vhodné zpracování. třídění je nutné, protože ve většině případů zůstávají data načtená ze zdroje špatně uspořádaná. Abychom nad tím triumfovali, bylo v průběhu let vytvořeno několik třídicích algoritmů. Podívejme se stručně na některé z používaných algoritmů třídění klíčů pomocí pythonového programování.
Top 6 třídících algoritmů v Pythonu
Níže jsou uvedeny různé třídicí algoritmy pro python:
1. Řazení bublin
Třídění bublin patří mezi nejčastěji používané třídicí techniky, počínaje prvními dvěma páry prvků zahrnuje třídění řady prvků porovnáním každé sousední dvojice prvků. takže když se vytvoří nesouosý řád, dojde k výměně prvků. Dokud poslední prvek ve vstupní sadě výše uvedený proces neznatelně nepokračuje, abychom optimalizovali algoritmus, vyzýváme k jeho zastavení po dokončení třídění. Jak možná zjistíme, že jsme dokončili třídění? to by mohlo být určeno, když jsou všechny dané položky v pořádku. Takže, kdykoli jsou proměnné zaměněny, mohl by být zachován příznak pro určení opětovného provedení procesu třídění. Příznak by měl být nastaven na false, pokud nejsou potřeba žádné další swapy.
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ýstup:
2. Výběr řazení
Výběrové třídění je jednou z nejzákladnějších třídicích technik. Tato technika zahrnuje nalezení nejméně nebo minimálního prvku z netříděné sady a umístění tohoto prvku na začátek netříděné sady. Při opakování těchto operací ve všech prvcích v sadě lze dosáhnout kompletně tříděné sady. Algoritmus odděluje seznam klíčů závislý na dvou různých částech. Vnitřní seznam nebo seznam odběrů bývají již roztříděny, což zahrnuje generování od prvku zcela vlevo k prvku zcela vpravo a dílčí seznam nevyřízených položek, které se mají setřídit a které obývají místo v seznamu. Nejprve je tříděný sublista nevyplněný a netříděný sublista je úplný seznam klíčů.
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ýstup:
3. Třídění vložení
Při třídění vložení se třídicí mechanismus provádí sestavením seřazeného pole s jednou položkou najednou. prvky pole jsou porovnány sekvenčním způsobem a poté uspořádány v jednom specifickém pořadí. Komponenty pole jsou porovnány postupně s každým z prvků a pak uspořádány současně v určitém pořadí. Analogie použitá v tomto dokumentu je velmi podobná uspořádání karet.
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ýstup:
4. Sloučit řazení
Sloučit řazení funguje na principu algoritmu dělení a dobývání. Zde je daný vstup sestaven do dvou polovin a spojené poloviny jsou tříděny a poté sloučeny. Ve vnímání pythonu je funkce merge () používána pro dosažení procesu sloučení. algoritmus pro řazení je jako níže,
- Zmíněné pole je třeba rozdělit na dvě různé části a za tímto účelem se stanoví střední hodnota pole.
- Sloučit řazení se použije v první polovině rozdělení.
- Pak je druhá polovina také vystavena tomu samému.
- Nakonec se po třídění segregované poloviny sloučí.
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ýstup:
5. Hromadné třídění
Hromadné třídění je forma techniky třídění výběru. Zahrnuje oddělení daného vstupu jako tříděných a netříděných prvků. Potom algoritmus smyčky takovým způsobem na netříděné oblasti, takže v každé smyčce bude do tříděné oblasti zatlačena největší hodnota. Tento proces bude pokračovat ve všech prvcích netříděné oblasti.
Z daného seznamu vstupů je vytvořena maximální halda. Poslední hodnota je pak opakovaně zaměňována s první hodnotou a také rozsah hodnot je poměrně snížen o jednu. Tento proces probíhá, dokud se rozsah nezmění 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ýstup:
6. Radix Sort
Radixovo třídění je technika třídění, která postupuje, aniž by se porovnávaly vložené prvky. Toho je dosaženo generováním kbelíku podle hodnoty radixu pro prvky s více než jednou číslicí, která je součástí, technika je použita pro všechny číslice v prvku. Nazývá se také druh kbelíku. Tato technika třídění bývá ve svých vhodných prostředích příliš rychlá.
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ýstup:
Závěr
V průběhu času existovalo mnoho algoritmů určených pro třídění vstupní sady. Byly navrženy s mottem dosažení lepší techniky a optimalizovaného výkonu v procesu třídění. Některé z nejdůležitějších jsou diskutovány výše. Z hlediska pythonu se tento jazyk vyznačuje velmi flexibilním a stabilním jazykem pro navrhování těchto algoritmů.
Doporučené články
Toto je Průvodce tříděním algoritmů v Pythonu. Zde diskutujeme úvodní a top 6 třídicí algoritmy v pythonu spolu s implementací kódu. Další informace naleznete také v následujících článcích
- Reverzní číslo pomocí různých způsobů v Pythonu
- Různé typy směrovacích algoritmů
- Typy pozemků v Matplotlibu v Pythonu
- Top 14 n-tic v Pythonu