Introduktion till sortering av algoritmer i Python
Sortering är en process för att ordna om elementen i någon ordning så att lämplig bearbetning kan tillämpas på det. sorteringen blir nödvändig eftersom i de flesta fall en data som hämtas från källan förblir dåligt ordnad. För att segra över detta skapades flera sorteringsalgoritmer under åren. låt oss kort diskutera några av de nyckelsorteringsalgoritmer som används med Python-programmering.
Topp 6 sorteringsalgoritmer i Python
Nedan är de olika sorteringsalgoritmerna för python:
1. Bubble Sort
Bubbelsortering är bland de vanligaste sorteringsteknikerna, med utgångspunkt från de första två paren av element innebär det att man sorterar en serie element genom att jämföra varje intilliggande par element. så när en felanpassad ordning upprättas sker byte av element. Fram till det sista elementet i ingångssatsen fortsätter processen ovan märkbart, för att optimera algoritmen uppmanar vi att stoppa den efter att den har slutfört sorteringen. Hur kan vi eventuellt konstatera att vi har slutfört sorteringen? detta kan bestämmas när alla givna objekt är i ordning. Så när variabler byts kan en flagga bibehållas för att bestämma återförandet av sorteringsprocessen. Flaggan ska ställas in som falsk när inga andra byten behövs.
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))
Produktion:
2. Urvalssortering
Urvalssortering är bland de mest baserande sorteringsteknikerna. Denna teknik involverar att hitta det minsta eller minsta elementet från den osorterade uppsättningen och placera det elementet i början av den osorterade uppsättningen. När man loopar dessa operationer över alla element i uppsättningen kan en helt sorterad uppsättning uppnås. Algoritmen segregerar nyckellistan ansluten till två olika delar. Den inre listan eller prenumerationslistan tenderar att redan sorteras, vilket innebär att generera från det vänstra elementet till det längst till höger, och underlistan över utmärkta objekt som ska sorteras som bor i listans respit. Först är den sorterade underlistan ouppfylld och den osorterade underlistan är den kompletta nyckellistan.
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))
Produktion:
3. Insertion Sort
I Insertion sorteras sorteringsmekanismen genom att bygga en sorterad matris med ett objekt åt gången. elementen i matrisen jämförs på ett sekventiellt sätt och arrangeras sedan i en specifik ordning. Komponenterna i matrisen jämförs i följd med vart och ett av elementen och beställs sedan samtidigt i en specifik ordning. Analogin som används här liknar mycket att ordna en uppsättning kort.
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))
Produktion:
4. Slå samman
Sortera sortering fungerar enligt principen om split och erövrar algoritm. Här splitsas den givna ingången i två halvor och de splitsade halvorna sorteras och slås sedan samman. I pythonuppfattning används fusionen () -funktionen för att uppnå sammanslagningsprocessen. algoritmen för insättningssortering är som nedan,
- Den nämnda matrisen måste delas upp i två olika delar och medianen för matrisen bestäms för detta.
- Sorteringssortering tillämpas under första halvan av delningen.
- Då utsätts den andra halvan också för samma.
- Till sist, efter sortering, slås de segregerade halvorna samman.
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)
Produktion:
5. Heap Sort
Heap sort är en form för urvalsorteringsteknik. Det handlar om att separera den givna ingången som sorterade och icke-sorterade element. Sedan slingas algoritmen på sådant sätt på det icke sorterade området så att på varje slinga skjutas det största värdet in i det sorterade området. Denna process kommer att fortsätta över alla element i den osorterade regionen.
En max hög skapas från den angivna inmatningslistan. Det sista värdet byts därefter upp med det första värdet upprepade gånger och också minskas värdesområdet jämförelsevis med ett. Denna process sker tills intervallet krymper till 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))
Produktion:
6. Radix Sort
Radix sortering är en sorteringsteknik som fortskrider utan att jämföra elementen som är inlagda. Detta uppnås genom att generera en hink enligt radixvärdet för element med mer än en siffra inblandad, tekniken tillämpas för alla siffror i elementet. Det benämns också som hinksortering. Denna sorteringsteknik tenderar att vara för snabb i sina lämpliga miljöer.
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)
Produktion:
Slutsats
Under en tidsperiod fanns det många algoritmer utformade för att sortera ingångsuppsättningen. De utformades med mottoet att uppnå bättre teknik och optimera exekvering i sorteringsprocessen. Några av de viktigaste diskuteras ovan. Från pythonperspektivet framstår detta språk som ett mycket flexibelt och stadigt språk för att få dessa algoritmer utformade.
Rekommenderade artiklar
Detta är en guide till sortering av algoritmer i Python. Här diskuterar vi introduktions- och topp 6-sorteringsalgoritmerna i python tillsammans med dess kodimplementering. Du kan också titta på följande artiklar för att lära dig mer-
- Återvända numret på olika sätt i Python
- Olika typer av routingsalgoritmer
- Typer av tomter i Matplotlib i Python
- Topp 14 tuples i Python