Увод у сортирање алгоритама у Питхон-у
Разврставање је процес преуређивања елемената по одређеном редоследу како би се на њега могла применити одговарајућа обрада. сортирање постаје неопходно јер у већини случајева подаци дохваћени из извора остају лоше наручени. Како би се победило ово, током година је створено неколико алгоритама за сортирање. нека нам укратко размотри неке кључне алгоритме сортирања који се користе помоћу питхон програмирања.
Топ 6 сортирања алгоритама на Питхон-у
Испод су различити алгоритми за сортирање питхона:
1. Буббле Сорт
Сорта мјехурића спада међу најчешће кориштене технике сортирања, почевши од прва два пара елемената, а укључује сортирање низа елемената упоређујући сваки сусједни пар елемената. па када се успостави неусклађени ред онда се врши замјена елемената. Све док последњи елемент у скупу улаза горњи поступак не буде видљив, ради оптимизације алгоритма, позивамо да га зауставимо након што је завршио сортирање. Како ћемо евентуално установити да смо сортирали? ово се може утврдити када су све дате ставке у реду. Дакле, кад год се измјене варијабле, застава се може одржати како би се утврдило поновно извршење поступка сортирања. Застава би требала бити постављена на фалсе када нису потребне друге замјене.
Шифра:
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))
Излаз:
2. Избор сортирања
Сортирање одабира је међу основним техникама сортирања. Ова техника укључује проналажење најмањег или минималног елемента из несортираног скупа и позиционирање тог елемента на почетку несортираног скупа. Када се ове операције петљају кроз све елементе у комплету, може се постићи потпуно сортиран скуп. Алгоритам сегрегира списак кључева закачен на два различита дела. Унутрашњи списак или листа претплате већ су сортирани, што укључује генерисање од најмањег левог до крајњег десног елемента и подврставање преосталих ставки које ће се сортирати и настају одмаком листе. У почетку је сортирани подлистак непотпун, а несортирани подлистак је потпуна листа кључева.
Шифра:
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))
Излаз:
3. Разврставање уметања
Уметање сортирања механизам за сортирање се врши тако што се сортира сортирани низ с једном ставком. елементи матрице се пореде на секвенцијални начин и затим преуређују у одређеном редоследу. Компоненте матрице се пореде узастопно са сваким од елемената и затим наручују истовремено одређеним редоследом. Аналогија која се овде користи је врло слична уређивању скупа карата.
Шифра:
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))
Излаз:
4. Мерге Сорт
Врста спајања ради на принципу подела и осваја алгоритам. Овде је дани улаз раздељен на две половине, а сложене половине су сортиране и затим спојене. У перцепцији питона, функција мерге () користи се за постизање процеса спајања. алгоритам сортирања уметања је доле наведен,
- Споменути низ се мора подијелити на два различита дијела и за то је одређен медијан поља.
- Врста спајања примењена је у првој половини поделе.
- Тада је и друга половина изложена истој.
- Најзад, након разврставања, раздвојене половине се спајају.
Шифра:
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)
Излаз:
5. Хеап Сорт
Хеап сорта је облик технике сортирања селекције. То укључује сегрегацију датог уноса као сортиране и несврстане елементе. Тада се алгоритам на тај начин петља на несврстану регију, тако да ће свака величина највећа вредност бити гурнута у сортирано подручје. Овај процес ће се наставити кроз све елементе у несортираном региону.
На датој листи уноса креира се максимална гомила. Посљедња вриједност се замјењује с првом вриједношћу више пута, а распон вриједности се компаративно смањује за један. Овај процес траје док се распон не смањи на 1.
Шифра:
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))
Излаз:
6. Радик сортирање
Радик сорт је техника сортирања која напредује без поређења елемената који су унети. То се постиже генерисањем канте према вредности радика за елементе са више од једне цифре, а техника се примењује за све цифре у елементу. Називају га и као врста кашике. Ова техника сортирања изгледа пребрзо у одговарајућим окружењима.
Шифра:
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)
Излаз:
Закључак
Током одређеног времена, постојали су бројни алгоритми дизајнирани за сортирање улазног скупа. Дизајнирани су под мотом да постигну бољу технику и оптимизују извршење у процесу сортирања. Неке од најважнијих расправљамо горе. Из питхон перспективе овај се језик истиче врло флексибилним и постојаним језиком за обликовање ових алгоритама.
Препоручени чланци
Ово је Водич за сортирање алгоритама у Питхон-у. Овде смо расправљали о увођењу и топ 6 алгоритама за сортирање у питхон-у заједно са његовом имплементацијом кода. Такође можете погледати следеће чланке да бисте сазнали више -
- Обртање броја на различите начине у Питхон-у
- Различите врсте алгоритама за усмјеравање
- Врсте парцела у Матплотлибу на Питхон-у
- Топ 14 Туплеса у Питхон-у