Bevezetés a rendezési algoritmusokba a Pythonban
A rendezés az elemek bizonyos sorrendben történő átrendezésének folyamata, hogy megfelelő feldolgozást lehessen alkalmazni rá. a válogatás akkor válik szükségessé, mert a forrásból kinyert adatok a legtöbb esetben rosszul vannak rendezve. Ennek győzelme érdekében az évek során számos válogatási algoritmust hoztak létre. röviden tárgyaljuk néhány, a python programozás során használt kulcs-rendezési algoritmust.
A 6 legfontosabb rendezési algoritmus a Pythonban
Az alábbiakban bemutatjuk a python különféle rendezési algoritmusait:
1. Bubble Sort
A buborékrendezés a leggyakrabban használt válogatási technikák között, az első két elempártól kezdve az elemek sorozatának szétválogatását jelenti minden szomszédos elempár összehasonlításával. tehát ha egy rosszul rendezett sorrendet hoznak létre, akkor az elemek cseréje történik. Mindaddig, amíg a bemeneti készlet utolsó elemét észrevehetően nem folytatják, az algoritmus optimalizálása érdekében felszólítunk arra, hogy állítsa le azt a rendezés befejezése után. Mennyire kiderül, hogy befejeztük a válogatást? ezt akkor lehet meghatározni, ha az összes adott elem rendben van. Tehát a változók cseréjekor a zászló fenntartható a rendezési folyamat újbóli végrehajtásának meghatározására. A zászlót hamis értékre kell állítani, ha nincs szükség más csereügyletre.
Kód:
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))
Kimenet:
2. Kiválasztás Rendezés
A válogatás a legalapvetőbb rendezési technikák közé tartozik. Ez a technika magában foglalja a legkisebb vagy minimális elem megkeresését a válogatott készletből és az elem elhelyezését a nem válogatott készlet elején. Ha ezeket a műveleteket a készlet összes elemére hurkolják, akkor egy teljesen rendezett halmaz érhető el. Az algoritmus elválasztja a kulcslistát, két különböző részre összekötve. A belső lista vagy az előfizetési lista általában már rendezve van, amely magában foglalja a bal oldali elemtől a jobb szélső elemig történő generálást, valamint a válogatás tárgyát képező, még rendezetlen tételek felsorolását, amelyek a lista ellenére élnek. Először a rendezett allista nem töltödik be, és a válogatott allista a teljes kulcslista.
Kód:
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))
Kimenet:
3. Beszúrás rendezése
A beszúrásban a válogatás mechanizmusát úgy végezzük, hogy válogatott tömböt épít egy elemmel egyszerre. a tömb elemeit egymás után összehasonlítjuk, majd egy meghatározott sorrendbe rendezzük. A tömb alkotóelemeit egymás után hasonlítják össze az egyes elemekkel, majd egyidejűleg, meghatározott sorrendben rendezik. Az itt alkalmazott analógia nagyon hasonló a kártyakészlet elrendezéséhez.
Kód:
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))
Kimenet:
4. Rendezés egyesítése
Az egyesítés rendezése az osztás és a hódítás algoritmusának elvén működik. Itt a megadott bemenetet két részre osztják, és az összeillesztett feleket szétválogatják, majd egyesítik. A python-észlelésben az merge () függvényt használjuk az egyesítési folyamat elérésére. a beszúrási sorrend algoritmusa az alábbiak szerint alakul,
- Az említett tömböt két különböző részre kell osztani és erre meg kell határozni a tömb mediánját.
- Az egyesítés sorrendjét a felosztás első felében alkalmazzák.
- Akkor a második felét szintén kitéve ennek.
- Végül, a válogatás után az elkülönített feleket egyesítik.
Kód:
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)
Kimenet:
5. Halomfajta
A halomfajta válogatás egyfajta formája. Ez magában foglalja az adott bemenet szétválasztását rendezett és nem rendezett elemekként. Ezután az algoritmus úgy hurkolódik a nem rendezett régióban, hogy mindegyik hurokon a legnagyobb érték kerüljön a rendezett régióba. Ezt a folyamatot folytatják a válogatott régióban lévő összes elemnél.
Az adott bemeneti listából maximális halom jön létre. Az utolsó értéket ezután ismételten felcseréljük az első értékre, és az értéktartományt viszonylag egyvel csökkentjük. Ez a folyamat addig zajlik, amíg a tartomány 1-re nem csökken.
Kód:
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))
Kimenet:
6. Radix Sort
A Radix rendezés egy olyan válogatási technika, amely a bevitt elemek összehasonlítása nélkül halad előre. Ezt úgy érik el, hogy egy vödröt generálnak a rádióértéknek megfelelő elemekkel, amelyeknél egynél több számjegy szerepel, a technikát az elem minden számére alkalmazzák. A vödörfajtának is nevezik. Ez a válogatási technika általában túl gyors a megfelelő környezetben.
Kód:
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)
Kimenet:
Következtetés
Egy bizonyos időszak alatt számos algoritmus volt a bemeneti halmaz rendezésére. Úgy tervezték, hogy jobb válasszák a technikát és optimalizálják a válogatási folyamatot. A legfontosabb kérdések közül néhányat fentebb tárgyalunk. Python szempontjából ez a nyelv nagyon rugalmas és állandó nyelv, amely ezen algoritmusok megtervezéséhez vezet.
Ajánlott cikkek
Ez egy útmutató az algoritmusok rendezéséhez Pythonban. Itt tárgyaljuk a bevezetést és a 6 legfontosabb válogató algoritmust a pythonban, valamint annak kódvégrehajtását. A következő cikkeket is megnézheti további információkért -
- A szám megfordítása különböző módon a Python-ban
- Az útválasztási algoritmusok különféle típusai
- Parcella típusok a Python Matplotlib-ban
- A 14 legfontosabb Tuples a Pythonban