Introduktion til sortering af algoritmer i Python
Sortering er en proces med at omorganisere elementerne i en eller anden rækkefølge, så der kan anvendes passende behandling på det. sorteringen bliver nødvendig, fordi data, der hentes fra kilden, i de fleste tilfælde forbliver dårligt beordrede. For at sejre over dette blev der skabt flere sorteringsalgoritmer gennem årene. lad os kort diskutere nogle af de nøglesorteringsalgoritmer, der bruges ved hjælp af python-programmering.
Top 6 sorteringsalgoritmer i Python
Nedenfor er de forskellige sorteringsalgoritmer for python:
1. Bubble Sort
Boblesortering er blandt de mest almindeligt anvendte sorteringsteknikker, der starter fra de første to par elementer, det indebærer sortering af en række elementer ved at sammenligne hvert tilstødende par elementer. så når en forkert tilpasset rækkefølge etableres, udskiftes elementer. Indtil det sidste element i input-indstillingen fortsættes ovenstående proces mærkbar, for at optimere algoritmen, opfordrer vi til at stoppe den, når den er afsluttet sortering. Hvordan kan vi muligvis finde ud af, at vi har afsluttet sorteringen? dette kunne bestemmes, når alle de givne poster er i rækkefølge. Så når variabler udveksles, kunne et flag opretholdes for at bestemme genudførelsen af sorteringsprocessen. Flaget skal indstilles til falsk, når der ikke er brug for andre swaps.
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))
Produktion:
2. Valgssortering
Valgssortering er blandt de mest baserende sorteringsteknikker. Denne teknik involverer at finde det mindst eller minimale element fra det usorterede sæt og placere det element i begyndelsen af det usorterede sæt. Når du looper disse operationer på tværs af alle elementer i sættet, kan der opnås et fuldstændigt sorteret sæt. Algoritmen adskiller nøglelisten, der er koblet til to forskellige dele. Den indre liste eller abonnementslisten har en tendens til at allerede er sorteret, hvilket indebærer generering fra elementet længst til venstre til elementet til højre og sublisten over emner, der er udestående til at blive sorteret, og som bor i listens pusterum. Først udfyldes den sorterede underliste, og den usorterede underliste er den komplette nøgelliste.
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))
Produktion:
3. Indsættelsessortering
I indsættelse sorteres sorteringsmekanismen ved at opbygge en sorteret matrix med et element ad gangen. elementerne i arrayet sammenlignes i rækkefølge og arrangeres derefter i en bestemt rækkefølge. Komponenterne i arrayet sammenlignes sekventielt med hvert af elementerne og bestilles derefter samtidigt i en bestemt rækkefølge. Den her anvendte analogi ligner meget at arrangere et sæt 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))
Produktion:
4. Flet sortering
Merge-sorteringen fungerer efter princippet om split og erobrer algoritme. Her splittes det givne input i to halvdele, og de splejsede halvdele sorteres og flettes derefter. I pythonopfattelse bruges fusionen () -funktionen til at opnå fusionsprocessen. algoritmen til indsættelsessorter er som nedenfor,
- Det nævnte array skal opdeles i to forskellige dele, og medianen for arrayet bestemmes for dette.
- Flettsorter anvendes i første halvdel af split.
- Derefter udsættes den anden halvdel også for den samme.
- Efter sortering flettes de adskilte halvdele til sidst.
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)
Produktion:
5. Heap Sort
Heap sortering er en form for udvælgelsessorteringsteknik. Det involverer at adskille det givne input som sorterede og ikke-sorterede elementer. Derefter sløjfer algoritmen på en sådan måde på det ikke-sorterede område, således at på hver løkke skubbes den største værdi ind i det sorterede område. Denne proces vil blive videreført på tværs af alle elementerne i det usorterede område.
En maksimal heap oprettes fra den givne inputliste. Den sidste værdi udskiftes derefter gentagne gange med den første værdi, og værdiområdet reduceres også relativt med en. Denne proces finder sted, indtil området falder 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))
Produktion:
6. Radix Sort
Radix sortering er en sorteringsteknik, der skrider frem uden at sammenligne de indtastede elementer. Dette opnås ved at generere en spand i henhold til radixværdien for elementer med mere end et cifre involveret, teknikken anvendes til alle cifrene i elementet. Det betegnes også som spandssortering. Denne sorteringsteknik har en tendens til at være for hurtig i deres egnede miljøer.
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)
Produktion:
Konklusion
Over en periode var der adskillige algoritmer designet til sortering af indgangssættet. De blev designet med mottoet om at opnå bedre teknik og optimeret udførelse i sorteringsprocessen. Nogle af de mest centrale diskuteres ovenfor. Fra python-perspektiv fremstår dette sprog som et meget fleksibelt og stabilt sprog til at få disse algoritmer designet.
Anbefalede artikler
Dette er en guide til sortering af algoritmer i Python. Her diskuterer vi introduktions- og top 6-sorteringsalgoritmer i python sammen med dens kodeimplementering. Du kan også se på de følgende artikler for at lære mere-
- Tilbageførsel af nummeret ved hjælp af forskellige måder i Python
- Forskellige typer routingalgoritmer
- Typer af plot i Matplotlib i Python
- Top 14 tuples i Python