Sissejuhatus algoritmide sortimisse Pythonis
Sorteerimine on elementide ümberkorraldamise protsess mingis järjekorras, nii et sellele saab rakendada sobivat töötlemist. sortimine osutub vajalikuks, kuna enamasti on allikast hangitud andmed halvasti järjestatud. Selle triumfiks loodi aastate jooksul mitu sortimisalgoritmi. arutame lühidalt mõnda peamist sortimisalgoritmi, mida python-programmeerimisel kasutatakse.
Pythonis 6 parimat sortimisalgoritmi
Allpool on toodud erinevad Python'i sortimisalgoritmid:
1. Mullide sortimine
Mullide sortimine on kõige sagedamini kasutatav sortimismeetod, alates kahest esimesest elementide paarist hõlmab see elementide seeria sorteerimist, kõrvutades iga külgnevat elementide paari. nii et kui kehtestatakse valesti paigutatud järjekord, toimub elementide vahetamine. Kuni sisendkomplekti viimase elemendini jätkatakse nähtavalt, et algoritmi optimeerimiseks palume see pärast sortimist lõpule viia. Kuidas on võimalik teada saada, et sorteerimine on lõpetatud? selle saab kindlaks teha, kui kõik antud üksused on korras. Nii et muutujate vahetamisel võiks sorteerimise uuesti teostamiseks kasutada lippu. Kui muid vahetusvahendeid pole vaja, peaks lipp olema vale.
Kood:
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äljund:
2. Valiku sortimine
Valiku sortimine on üks kõige põhilisemaid sortimisvõtteid. See meetod hõlmab sorteerimata komplekti hulgast vähima või minimaalse elemendi leidmist ja selle elemendi positsioneerimist sorteerimata komplekti alguses. Nende toimingute silmustamisel kõigi komplekti elementide vahel on võimalik saada täiesti sorteeritud komplekt. Algoritm eraldab võtmeloendi, mis on ühendatud kahe erineva osaga. Sisemine loend või tellimisnimekiri kipuvad olema juba sorteeritud, mis hõlmab genereerimist vasakpoolsest elemendist parempoolseimani ja sorteerimata toodete alamloendit, mis asuvad loendi lõpus. Alguses on sorteeritud alamloend täitmata ja sorteerimata alamloend on täielik võtmeloend.
Kood:
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äljund:
3. Sisestuse sortimine
Sisestuses sorteeritakse sortimismehhanism, ehitades sorteeritud massiivi üksusega korraga. massiivi elemente võrreldakse järjestikku ja järjestatakse seejärel ühes kindlas järjekorras. Massiivi komponente võrreldakse järjestikku iga elemendiga ja seejärel järjestatakse need kindlas järjekorras samaaegselt. Siin kasutatud analoogia on väga sarnane kaardikomplekti korraldamisega.
Kood:
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äljund:
4. Ühenda sortimine
Merge sort töötab jagamise põhimõttel ja vallutab algoritmi. Siin jagatakse antud sisend kaheks pooleks ja jagatud pooled sorteeritakse ja ühendatakse. Püütoni tajumisel kasutatakse liitmisprotsessi saavutamiseks funktsiooni merge (). sisestamise sortimise algoritm on nagu allpool,
- Mainitud massiiv tuleb jagada kaheks erinevaks osaks ja selleks määratakse massiivi mediaan.
- Ühendamise sortimist rakendatakse jaotuse esimesel poolel.
- Siis paljastatakse sama ka teine pool.
- Lõpuks, pärast sortimist, liidetakse eraldatud pooled.
Kood:
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äljund:
5. Hunniku sorteerimine
Hunnikute sortimine on sorteerimistehnika vorm. See hõlmab antud sisendi eraldamist sorteeritud ja sortimata elementidena. Seejärel silmub algoritm sorteerimata piirkonnas selliselt, et igal silmusel surutakse suurim väärtus järjestatud piirkonda. Seda protsessi jätkatakse kõigi sortimata piirkonna elementide osas.
Antud sisendite loendist luuakse maksimaalne hunnik. Seejärel vahetatakse viimane väärtus korduvalt esimese väärtusega ja ka väärtusvahemikku vähendatakse suhteliselt ühe võrra. See protsess toimub seni, kuni vahemik kahaneb 1-ni.
Kood:
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äljund:
6. Radixi sort
Radixi sortimine on sorteerimistehnika, mida kasutatakse sisestatud elementide võrdlemata. Selle saavutamiseks genereeritakse kopp vastavalt raadiosaatja väärtusele elementide jaoks, milles on rohkem kui üks number, tehnikat rakendatakse kõigi elemendi numbrite jaoks. Seda nimetatakse ka ämbrisorteerimiseks. See sorteerimistehnika kipub olema sobivas keskkonnas liiga kiire.
Kood:
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äljund:
Järeldus
Teatud aja jooksul oli arvukalt algoritme, mis olid loodud sisendikomplekti sorteerimiseks. Nende eesmärk oli saavutada parem tehnika ja optimeerida teostamist sortimisprotsessis. Mõned kõige olulisemad neist on arutatud eespool. Püütoni vaatenurgast paistab see keel olevat väga paindlik ja püsiv keel nende algoritmide kujundamiseks.
Soovitatavad artiklid
See on juhend algoritmide sortimiseks Pythonis. Siin käsitleme sissejuhatust ja 6 populaarseimat sortimisalgoritmi pythonis koos selle koodi rakendamisega. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -
- Numbri pööramine Pythonil erinevatel viisidel
- Marsruutimisalgoritmide erinevad tüübid
- Krunditüübid Pythonis Matplotlibis
- Pythonis 14 parimat Tupli