Inleiding tot sorteeralgoritmen in Python
Sorteren is een proces waarbij de elementen in een bepaalde volgorde worden herschikt, zodat er een geschikte verwerking op kan worden toegepast. het sorteren wordt noodzakelijk omdat in de meeste gevallen gegevens die uit de bron zijn opgehaald, slecht geordend blijven. Om dit te overwinnen, zijn in de loop van de jaren verschillende sorteeralgoritmen gecreëerd. laten we kort enkele van de belangrijkste sorteeralgoritmen bespreken die worden gebruikt met behulp van python-programmering.
Top 6 Sorteeralgoritmen in Python
Hieronder staan de verschillende sorteeralgoritmen voor python:
1. Bellen sorteren
Bubbelsortering is een van de meest gebruikte sorteertechnieken, beginnend bij de eerste twee paar elementen, waarbij een reeks elementen wordt gesorteerd door elk aangrenzend paar elementen te vergelijken. dus wanneer een verkeerd uitgelijnde volgorde wordt vastgesteld, vindt het verwisselen van elementen plaats. Tot het laatste element in de invoerset wordt het bovenstaande proces merkbaar voortgezet, om het algoritme te optimaliseren, vragen we om het te stoppen nadat het sorteren is voltooid. Hoe kunnen we vaststellen dat we het sorteren hebben voltooid? dit kan worden bepaald wanneer alle gegeven items in orde zijn. Dus, wanneer variabelen worden verwisseld, kan een vlag worden onderhouden om de heruitvoering van het sorteerproces te bepalen. De vlag moet worden ingesteld op onwaar als er geen andere swaps nodig zijn.
Code:
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))
Output:
2. Selectie sorteren
Selectie sorteren is een van de meest baserende sorteertechnieken. Deze techniek omvat het vinden van het minste of minimale element uit de ongesorteerde set en het positioneren van dat element aan het begin van de ongesorteerde set. Bij het doorlussen van deze bewerkingen over alle elementen in de set kan een volledig gesorteerde set worden bereikt. Het algoritme scheidt de toetsenlijst die aan twee verschillende delen is gekoppeld. De binnenlijst of de abonnementslijst zijn meestal al gesorteerd, wat inhoudt dat van het meest linkse element naar het meest rechtse element wordt gegenereerd, en de sublijst van te sorteren items die moeten worden gesorteerd in afwachting van de lijst. Eerst wordt de gesorteerde sublijst niet ingevuld en is de ongesorteerde sublijst de volledige sleutellijst.
Code:
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))
Output:
3. Invoegsortering
Bij invoegsortering wordt het sorteermechanisme uitgevoerd door een gesorteerde array met één item tegelijk te bouwen. de elementen van de reeks worden op een opeenvolgende manier vergeleken en vervolgens in een specifieke volgorde herschikt. De componenten van de reeks worden opeenvolgend met elk van de elementen vergeleken en vervolgens gelijktijdig in een specifieke volgorde geordend. De analogie die hier wordt gebruikt, lijkt erg op het rangschikken van een set kaarten.
Code:
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))
Output:
4. Sorteren samenvoegen
De soort Samenvoegen werkt volgens het principe van verdeel en overwint algoritme. Hier wordt de gegeven invoer in twee helften gesplitst en worden de gesplitste helften gesorteerd en vervolgens samengevoegd. In python-perceptie wordt de functie merge () gebruikt om het samenvoegproces te bereiken. het algoritme voor invoegsortering is als volgt,
- De genoemde array moet worden opgesplitst in twee verschillende delen en de mediaan van de array wordt hiervoor bepaald.
- Samenvoegen wordt toegepast in de eerste helft van de splitsing.
- Dan wordt ook de tweede helft hieraan blootgesteld.
- Eindelijk worden na het sorteren de gescheiden helften samengevoegd.
Code:
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)
Output:
5. Heap sorteren
Heap-sortering is een vorm van selectiesorteringstechniek. Het gaat om het scheiden van de gegeven invoer als gesorteerde en niet-gesorteerde elementen. Vervolgens loopt het algoritme op een dergelijke manier in het niet-gesorteerde gebied, zodat op elke lus de grootste waarde in het gesorteerde gebied wordt geduwd. Dit proces wordt voortgezet voor alle elementen in het ongesorteerde gebied.
Er wordt een maximale heap gemaakt van de gegeven invoerlijst. De laatste waarde wordt vervolgens herhaaldelijk verwisseld met de eerste waarde en ook het waardebereik wordt relatief met één verlaagd. Dit proces vindt plaats totdat het bereik krimpt tot 1.
Code:
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))
Output:
6. Radix sorteren
Radix-sortering is een sorteertechniek die vordert zonder de ingetoetste elementen te vergelijken. Dit wordt bereikt door een bucket te genereren volgens de radixwaarde voor elementen met meer dan één cijfer. De techniek wordt toegepast voor alle cijfers in het element. Het wordt ook wel emmersoort genoemd. Deze sorteertechniek is vaak te snel in de geschikte omgevingen.
Code:
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)
Output:
Conclusie
Over een periode van tijd waren er talloze algoritmen ontworpen voor het sorteren van de invoerset. Ze zijn ontworpen met het motto om een betere techniek en een optimale uitvoering in het sorteerproces te bereiken. Enkele van de belangrijkste zijn hierboven besproken. Vanuit het perspectief van Python valt deze taal op als een zeer flexibele en stabiele taal om deze algoritmen ontworpen te krijgen.
Aanbevolen artikelen
Dit is een gids voor het sorteren van algoritmen in Python. Hier bespreken we de introductie en de top 6 sorteeralgoritmen in python samen met de implementatie van de code. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Het getal omkeren op verschillende manieren in Python
- Verschillende soorten routeringsalgoritmen
- Soorten plaatsen in Matplotlib in Python
- Top 14 Tuples in Python