Uvod v razvrščanje algoritmov v Pythonu
Razvrščanje je postopek preureditve elementov v nekem vrstnem redu, tako da se nanj lahko uporabi primerna obdelava. razvrščanje postane potrebno, ker v večini primerov podatki, pridobljeni iz vira, ostanejo slabo urejeni. Za zmago nad tem je bilo v letih ustvarjenih več algoritmov za razvrščanje. na kratko razpravimo o nekaterih ključnih algoritmih za razvrščanje, ki se uporabljajo pri programiranju python-a.
Najboljših 6 algoritmov za razvrščanje v Pythonu
Spodaj so različni algoritmi razvrščanja pythona:
1. Razporeditev mehurčkov
Razporeditev mehurčkov je med najpogosteje uporabljenimi tehnikami razvrščanja, začenši od prvih dveh parov elementov, ki vključuje razvrščanje niza elementov s primerjavo vsakega sosednjega para elementov. ko se vzpostavi neskladen vrstni red, potem pride do zamenjave elementov. Dokler zadnji element v vhodnem nizu zgornji postopek ne bo zaznaven, za optimizacijo algoritma pozivamo, da ga zaustavimo po končanem razvrščanju. Kako bomo morda ugotovili, da smo zaključili razvrščanje? to bi bilo mogoče določiti, ko so vse dane postavke v redu. Torej, kadar se zamenjajo spremenljivke, se lahko ohrani zastava za določitev ponovne izvedbe postopka razvrščanja. Kadar ni treba zamenjati drugih, mora biti zastava nastavljena na false.
Koda:
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))
Izhod:
2. Razvrstitev izbire
Selekcijsko razvrščanje spada med najbolj temeljne tehnike razvrščanja. Ta tehnika vključuje iskanje najmanjšega ali najmanjšega elementa iz nesortiranega niza in postavitev tega elementa na začetek nesortiranega niza. Ob preklopu teh operacij v vse elemente v nizu je mogoče doseči popolnoma razvrščen niz. Algoritem loči seznam ključev, ki je povezan na dva različna dela. Notranji seznam ali seznam naročnikov je ponavadi že razvrščen, kar vključuje generiranje od skrajnega levega do skrajnega desnega elementa in podštevilke neporavnanih elementov, ki so razvrščeni, ki naseljujejo odmik seznama. Sprva je razvrščen podpis nepolnjen, neortirani podpisnik pa popoln seznam ključev.
Koda:
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))
Izhod:
3. Razvrščanje vstavka
Pri vstavitvi razvrstite mehanizem za razvrščanje tako, da zgradite razvrščen niz z enim elementom naenkrat. elementi matrike se zaporedno primerjajo in nato preuredijo v določenem zaporedju. Komponente matrike se zaporedno primerjajo z vsakim od elementov in jih nato naročijo istočasno v določenem zaporedju. Tu uporabljena analogija je zelo podobna urejanju nabora kart.
Koda:
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))
Izhod:
4. Združi razvrstitev
Razvrstitev združitev deluje na principu delitve in osvaja algoritem. Tu se dani vhod razdeli na dve polovici in zdrobljene polovice se razvrstijo in nato združijo. Pri zaznavanju python-a se funkcija merge () uporablja za doseganje procesa spajanja. algoritem za razvrstitev vstavljanja je spodaj,
- Omenjeni niz je treba razdeliti na dva različna dela in za to je določena mediana matrike.
- Razporeditev združevanja se uporablja v prvi polovici delitve.
- Nato je enaka izpostavljena tudi druga polovica.
- Nazadnje se po razvrščanju ločene polovice združijo.
Koda:
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)
Izhod:
5. Heap Sort
Razvrščanje po kupu je oblika tehnike izbora sortiranja. Vključuje ločevanje danega vnosa kot razvrščene in nerazvrščene elemente. Nato algoritem na tak način zlepi na nerazvrščeno območje, tako da bo v vsaki zanki največja vrednost potisnjena v razvrščeno območje. Ta postopek se bo nadaljeval v vseh elementih v nesortiranem območju.
Na danem seznamu vnosov se ustvari največ kopice. Zadnja vrednost se večkrat zamenja s prvo vrednostjo, prav tako pa se vrednost vrednosti ustrezno zmanjša za eno. Ta postopek poteka, dokler se razpon ne zmanjša na 1.
Koda:
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))
Izhod:
6. Razvrstitev Radix
Razvrščanje Radix je tehnika razvrščanja, ki napreduje brez primerjave elementov, vpisanih. To dosežemo z generiranjem vedra glede na vrednost radiksa za elemente z več kot eno števko, ki se uporablja za vse števke v elementu. Imenujejo ga tudi kot sortiranje vedra. Ta tehnika razvrščanja je ponavadi prehitro v primernih okoljih.
Koda:
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)
Izhod:
Zaključek
V daljšem obdobju so bili oblikovani številni algoritmi za razvrščanje vhodnega niza. Zasnovani so bili z geslom za doseganje boljše tehnike in optimizirane izvedbe v postopku razvrščanja. Nekaj najbolj ključnih je obravnavanih zgoraj. Z vidika pythona ta jezik izstopa kot zelo prilagodljiv in stabilen jezik za oblikovanje teh algoritmov.
Priporočeni članki
To je vodnik za razvrščanje algoritmov v Pythonu. Tukaj razpravljamo o uvedbi in top 6 algoritmih za razvrščanje v pythonu, skupaj z njegovo implementacijo kode. Če želite izvedeti več, si oglejte tudi naslednje članke -
- Spremeniti številko na različne načine v Pythonu
- Različne vrste algoritmov za usmerjanje
- Vrste parcel v Matplotlibu v Pythonu
- Najboljših 14 Tuplesov v Pythonu