Introducere în Sortarea Algoritmilor în Python
Sortarea este un proces de reorganizare a elementelor într-o anumită ordine, astfel încât să i se poată aplica o prelucrare adecvată. sortarea devine necesară deoarece, în majoritatea cazurilor, datele preluate din sursă rămân prost ordonate. Pentru a triumfa acest lucru, de-a lungul anilor s-au creat mai mulți algoritmi de sortare. haideți să discutăm pe scurt unele dintre algoritmii de sortare a cheilor utilizate cu ajutorul programării python.
Top 6 Sortarea algoritmilor din Python
Mai jos sunt diferiți algoritmi de sortare pentru python:
1. Sortare cu bule
Sortarea cu bule este una dintre cele mai utilizate tehnici de sortare, pornind de la primele două perechi de elemente implică sortarea unei serii de elemente prin compararea fiecărei perechi de elemente adiacente. deci atunci când se stabilește o ordine nealiniată, atunci are loc schimbul de elemente. Până la ultimul element din setul de intrare, procesul de mai sus este continuat perceptibil, pentru a optimiza algoritmul, solicităm oprirea acestuia după finalizarea sortării. Cum vom face posibil să terminăm sortarea? acest lucru ar putea fi determinat atunci când toate elementele date sunt în ordine Deci, ori de câte ori variabilele sunt schimbate, un steag ar putea fi menținut pentru a determina reexecutarea procesului de sortare. Steagul trebuie să fie setat pe false atunci când nu este nevoie de alte schimburi.
Cod:
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))
ieşire:
2. Sortare selecție
Sortarea selecției este printre cele mai bazate tehnici de sortare. Această tehnică implică găsirea elementului minim sau minim din setul nesortat și poziționarea acelui element la începutul setului nesortat. La bucla acestor operații pe toate elementele din set poate fi realizat un set complet sortat. Algoritmul segrește lista de chei agățată în două părți diferite. Lista interioară sau lista de abonamente tind să fie deja sortate, ceea ce implică generarea de la cel mai stânga element la cel mai bun element, iar sub-lista elementelor restante care trebuie sortate care locuiesc în răgazul listei. La început, sublistul sortat nu este completat, iar sublistul nesortat este lista completă de chei.
Cod:
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))
ieşire:
3. Sortare inserție
În inserare sortarea mecanismului de sortare se realizează prin construirea unui tablou sortat cu un element la un moment dat. elementele tabloulului sunt comparate într-o manieră secvențială și apoi rearanjate într-o ordine specifică. Componentele tabloului sunt comparate secvențial cu fiecare dintre elemente și apoi sunt ordonate simultan într-o ordine specifică. Analogia folosită aici este foarte similară cu aranjarea unui set de cărți.
Cod:
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))
ieşire:
4. Sortare Merge
Sortul Merge funcționează pe principiul algoritmului de împărțire și cucerire. Aici, intrarea dată este împărțită în două jumătăți și jumătățile despicate sunt sortate și apoi îmbinate. În percepția piton, funcția merge () este utilizată pentru realizarea procesului de îmbinare. algoritmul pentru sortarea de inserție este ca mai jos,
- Matricea menționată trebuie împărțită în două părți diferite și mediana tabloului este determinată pentru aceasta.
- Sortul combinat se aplică în prima jumătate a divizării.
- Apoi, a doua jumătate este, de asemenea, expusă la același lucru.
- În cele din urmă, după sortare, jumătățile segregate sunt contopite.
Cod:
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)
ieşire:
5. Sortare la grămadă
Sortarea haldelor este o formă de tehnică de sortare a selecției. Ea implică segregarea intrării date ca elemente sortate și ne-sortate. Apoi, algoritmul se bucle într-o asemenea manieră pe regiunea care nu este sortată, astfel încât pe fiecare buclă cea mai mare valoare va fi împinsă în regiunea sortată. Acest proces va fi continuat pe toate elementele din regiunea nesortată.
O listă maximă este creată din lista de intrare dată. Ultima valoare este apoi schimbată cu prima valoare în mod repetat și, de asemenea, intervalul de valori este comparativ redus cu una. Acest proces are loc până când intervalul se reduce la 1.
Cod:
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))
ieşire:
6. Sortare Radix
Radix sort este o tehnică de sortare care progresează fără a compara elementele introduse. Aceasta se realizează prin generarea unei găleți în funcție de valoarea radix pentru elementele cu mai mult de o cifră implicată. Tehnica este aplicată pentru toate cifrele din element. Este, de asemenea, denumit ca sort de găleată. Această tehnică de sortare tinde să fie prea rapidă în mediile lor adecvate.
Cod:
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)
ieşire:
Concluzie
Pe parcursul unei perioade de timp, au existat numeroși algoritmi concepuți pentru sortarea setului de intrare. Au fost concepute cu motto-ul de a realiza o tehnică mai bună și o execuție optimizată în procesul de sortare. Unele dintre cele mai cheie sunt discutate mai sus. Din perspectiva python, acest limbaj se evidențiază ca un limbaj foarte flexibil și constant pentru obținerea acestor algoritmi proiectați.
Articole recomandate
Acesta este un ghid pentru sortarea algoritmilor în Python. Aici discutăm introducerea și top 6 algoritmi de sortare în python împreună cu implementarea codului. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-
- Inversarea numărului folosind diferite moduri în Python
- Diverse tipuri de algoritmi de rutare
- Tipuri de parcele în Matplotlib în Python
- Top 14 Tuples din Python