Johdatus algoritmien lajitteluun Pythonissa
Lajittelu on prosessi, jossa elementit järjestetään uudelleen tietyssä järjestyksessä, jotta siihen voidaan soveltaa sopivaa käsittelyä. lajittelu tulee välttämättömäksi, koska lähdekoodista haettu data pysyy useimmiten huonosti järjestettynä. Voiton saavuttamiseksi vuosien varrella luotiin useita lajittelualgoritmeja. keskustelemme lyhyesti joistakin avainten lajittelualgoritmeista, joita käytetään python-ohjelmoinnilla.
Kuusi suosituinta lajittelualgoritmia Pythonissa
Alla on python-lajittelualgoritmit:
1. Kuplalajittelu
Kuplalajittelu on yleisimmin käytettyjen lajittelumenetelmien joukossa, alkaen kahdesta ensimmäisestä elementtiparista, siihen sisältyy elementtisarjan lajittelu vertaamalla jokaista vierekkäistä elementtiparia. joten kun vääränlainen järjestys on perustettu, tapahtuu elementtien vaihtaminen. Ennen kuin sisäänsyöttöjoukon viimeistä elementtiä yllä mainittua prosessia jatketaan näkyvästi, algoritmin optimoimiseksi vaadimme lopettamaan sen järjestämisen jälkeen. Kuinka mahdollisesti selvitämme, että lajittelu on suoritettu loppuun? tämä voitiin määrittää, kun kaikki annetut kohteet ovat kunnossa. Joten aina kun muuttujia vaihdetaan, lippua voitaisiin ylläpitää lajitteluprosessin uudelleen suorittamiseksi. Lippu tulee asettaa väärään, kun muita vaihtoja ei tarvita.
Koodi:
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))
lähtö:
2. Valintalajittelu
Valintalajittelu on yksi perustyyppisimmistä lajittelutekniikoista. Tämä tekniikka sisältää pienimmän tai pienimmän elementin löytämisen lajittelemattomasta joukosta ja sen sijoittamisen lajittelemattoman joukon alkuun. Silmukoitaessa nämä toiminnot sarjan kaikille elementeille voidaan saavuttaa täysin lajiteltu joukko. Algoritmi erottaa avainluettelon koukussa kahdesta eri osasta. Sisäluettelolla tai tilausluettelolla on taipumus jo lajitella, mikä merkitsee luomista vasemmalta elementiltä oikeanpuoleisimpaan elementtiin ja alaluetteloon lajitteltavista jäljellä olevista tuotteista, jotka asuvat luettelon takana. Aluksi lajiteltu alaluettelo on täyttämättä ja lajittelematon alaluettelo on täydellinen avainluettelo.
Koodi:
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))
lähtö:
3. Lisäyslajittelu
Lisäyksessä lajittelu lajittelumekanismi suoritetaan rakentamalla lajiteltu taulukko yhdellä esineellä kerrallaan. taulukon elementtejä verrataan peräkkäin ja järjestetään sitten uudelleen yhteen tiettyyn järjestykseen. Matriisin komponentteja verrataan peräkkäin kuhunkin elementtiin ja sitten ne järjestetään samanaikaisesti tietyssä järjestyksessä. Tässä käytetty analogia on hyvin samanlainen kuin korttisarjan järjestäminen.
Koodi:
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))
lähtö:
4. Yhdistä lajittelu
Yhdistämislajittelu toimii jakoperiaatteella ja valloittaa algoritmia. Tässä annettu tulo silmukoidaan kahteen puolikkaaseen ja silmukoidut puolikkaat lajitellaan ja yhdistetään sitten. Python-käsityksessä yhdistämisprosessia (merge) käytetään yhdistämisprosessin saavuttamiseen. lisäyslajittelualgoritmi on kuten alla,
- Mainittu taulukko on jaettava kahteen eri osaan ja taulukon mediaani määritetään tätä varten.
- Yhdistämislajittelu tapahtuu jaon ensimmäisellä puoliskolla.
- Sitten myös toinen puoli altistetaan samalle.
- Viimeinkin lajittelun jälkeen erotetut puolikkaat yhdistetään.
Koodi:
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)
lähtö:
5. Heap Sort
Kasalajittelu on eräänlainen valintalajittelulaji. Siihen sisältyy annetun syötteen erottaminen lajitelluiksi ja lajittelemattomiksi elementeiksi. Sitten algoritmi silmukoi tällä tavalla lajittelemattomalla alueella siten, että jokaisella silmukalla suurin arvo työnnetään lajiteltuun alueeseen. Tätä prosessia jatketaan lajittelemattoman alueen kaikilla elementeillä.
Annetusta syöttölistasta luodaan maksimikasa. Viimeinen arvo vaihdetaan sitten ensimmäisellä arvolla toistuvasti ja myös arvoaluetta pienennetään suhteellisen yhdellä. Tämä prosessi tapahtuu, kunnes alue pienenee arvoon 1.
Koodi:
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))
lähtö:
6. Radix-lajittelu
Radix-lajittelu on lajittelumenetelmä, joka etenee vertaamattomia näppäimiä elementtejä. Tämä saavutetaan generoimalla ämpäri radix-arvon mukaan elementeille, joissa on useampi kuin yksi numero, tekniikkaa sovelletaan kaikissa elementin numeroissa. Sitä kutsutaan myös kauhan lajitteluun. Tämä lajittelutekniikka on yleensä liian nopea sopivissa ympäristöissä.
Koodi:
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)
lähtö:
johtopäätös
Ajanjakson aikana oli olemassa lukuisia algoritmeja, jotka on suunniteltu tulojoukon lajittelua varten. Niiden suunnittelussa on motto saavuttaa parempi tekniikka ja optimoitu suoritus lajitteluprosessissa. Joitakin tärkeimmistä käsitellään edellä. Python-näkökulmasta tämä kieli osoittautuu erittäin joustavaksi ja tasaiseksi kieleksi näiden algoritmien suunnittelussa.
Suositellut artikkelit
Tämä on opas algoritmien lajitteluun Pythonissa. Tässä keskustellaan johdannosta ja kuudesta pythonin lajittelualgoritmista sen koodin toteutuksen kanssa. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja-
- Numeron kääntäminen eri tavoilla Pythonissa
- Erityyppiset reititysalgoritmit
- Tontit Matplotlibissä Pythonissa
- Pythonin 14 parasta Tuplia