Introduksjon til sortering av algoritmer i Python
Sortering er en prosess med å omorganisere elementene i en viss rekkefølge, slik at passende prosessering kan brukes på det. sorteringen blir nødvendig fordi i de fleste tilfeller data hentet fra kilden forblir dårlig ordnet. For å seire over dette ble flere sorteringsalgoritmer opprettet gjennom årene. la oss diskutere kort noen av nøkkelsorteringsalgoritmene som brukes ved bruk av python-programmering.
Topp 6 sorteringsalgoritmer i Python
Nedenfor er de forskjellige sorteringsalgoritmene for python:
1. Bubble Sort
Boblesortering er blant de mest brukte sorteringsteknikkene. Fra de to første elementparene innebærer det å sortere en serie elementer ved å sammenligne hvert tilstøtende par elementer. så når en feiljustert rekkefølge er opprettet, skjer det bytte av elementer. Inntil det siste elementet i inngangssettet ovennevnte prosess videreføres merkbart, for å optimalisere algoritmen, ber vi om å stoppe den etter at den er fullført sortering. Hvordan kan vi muligens finne ut at vi har fullført sorteringen? Dette kan bestemmes når alle oppgitte elementer er i orden. Så når variabler byttes, kan et flagg opprettholdes for å bestemme gjenoppføringen av sorteringsprosessen. Flagget skal settes til usant når ingen andre bytter er nødvendig.
Kode:
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))
Produksjon:
2. Utvalgssortering
Utvalgssortering er blant de mest baserende sorteringsteknikkene. Denne teknikken innebærer å finne det minste eller minste elementet fra det usorterte settet og plassere det elementet i begynnelsen av det usorterte settet. Når du looper disse operasjonene over alle elementene i settet, kan du oppnå et fullstendig sortert sett. Algoritmen segregerer nøkkelisten som er koblet til to forskjellige deler. Den indre listen eller abonnementslisten har en tendens til å allerede være sortert, noe som innebærer generering fra elementet til venstre til elementet til høyre, og dellisten over utestående elementer som skal sorteres og som bor i respiten på listen. Til å begynne med er den sorterte sublisten ufylt, og den usorterte sublisten er den komplette nøkkelisten.
Kode:
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))
Produksjon:
3. Sett inn sortering
I innsetting sorteres sorteringsmekanismen ved å bygge en sortert matrise med ett element av gangen. elementene i matrisen blir sammenlignet på en sekvensiell måte og deretter omorganisert i en spesifikk rekkefølge. Komponentene i matrisen blir sammenlignet sekvensielt med hvert av elementene og deretter bestilt samtidig i en spesifikk rekkefølge. Analogien som brukes her, ligner veldig på å arrangere et sett med kort.
Kode:
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))
Produksjon:
4. Slå sammen sortering
Merge-sorteringen fungerer etter prinsippet om splittelse og erobrer algoritme. Her blir den gitte inngangen skjøvet i to halvdeler og de skjøte halvdelene sortert og deretter slått sammen. I python-persepsjon brukes fusjonen () -funksjonen for å oppnå fusjonsprosessen. algoritmen for innsetting er som nedenfor,
- Den nevnte matrisen må deles i to forskjellige deler, og medianen til arrayet bestemmes for dette.
- Flettesortering brukes i første halvdel av delingen.
- Da blir også andre omgang utsatt for det samme.
- Til slutt, etter sortering, blir de segregerte halvdelene slått sammen.
Kode:
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)
Produksjon:
5. Heap Sort
Heap sort er en form for utvalgssorteringsteknikk. Det innebærer å separere den gitte inngangen som sorterte og ikke-sorterte elementer. Da sløyfes algoritmen på en slik måte på det ikke-sorterte området, slik at på hver sløyfe blir den største verdien presset inn i det sorterte området. Denne prosessen vil bli videreført på tvers av alle elementene i det usorterte området.
En maksimal haug opprettes fra den gitte inngangslisten. Den siste verdien blir deretter byttet ut med den første verdien gjentatte ganger, og også verdiområdet blir relativt redusert med en. Denne prosessen foregår til området krymper til 1.
Kode:
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))
Produksjon:
6. Radix Sort
Radix sortering er en sorteringsteknikk som utvikler seg uten å sammenligne elementene som er tastet inn. Dette oppnås ved å generere en bøtte i henhold til radixverdien for elementer med mer enn ett siffer involvert, teknikken blir brukt for alle sifrene i elementet. Det betegnes også som bøttesortering. Denne sorteringsteknikken har en tendens til å være for rask i de passende miljøene.
Kode:
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)
Produksjon:
Konklusjon
Over en periode var det mange algoritmer designet for å sortere inngangssettet. De ble designet med mottoet om å oppnå bedre teknikk og optimalisert utførelse i sorteringsprosessen. Noen av de viktigste er omtalt ovenfor. Fra pythonperspektiv fremstår dette språket som et veldig fleksibelt og jevn språk for å få disse algoritmene designet.
Anbefalte artikler
Dette er en guide til sortering av algoritmer i Python. Her diskuterer vi introduksjonen og topp 6 sorteringsalgoritmer i python sammen med kodeimplementeringen. Du kan også se på følgende artikler for å lære mer-
- Å reversere tallet ved å bruke forskjellige måter i Python
- Ulike typer rutingsalgoritmer
- Typer av tomter i Matplotlib i Python
- Topp 14 tuples i Python