Въведение в сортирането на алгоритми в Python
Сортирането е процес на пренареждане на елементите в някакъв ред, за да може да се приложи подходяща обработка към него. сортирането става необходимо, тъй като в повечето случаи данните, извлечени от източника, остават лошо подредени. За да постигне триумф над това, през годините бяха създадени няколко алгоритми за сортиране. нека да обсъдим накратко някои от ключовите алгоритми за сортиране, използвани с програмиране на python.
Топ 6 алгоритми за сортиране в Python
По-долу са описани различните алгоритми за сортиране на python:
1. Сортиране на балончета
Сортирането на балоните е сред най-често използваните техники за сортиране, като се започне от първите два чифта елементи, включва сортиране на поредица от елементи, като се сравняват всяка съседна двойка елементи. така че когато се установи несъответствие, тогава се извършва размяна на елементи. Докато последният елемент от входния набор горепосоченият процес продължава да се забележи, за да оптимизираме алгоритъма, призоваваме да го спрем, след като завърши сортирането. Как е възможно да разберем, че сме завършили сортирането? това може да се определи, когато всички зададени елементи са в ред. Така че, когато се променят променливи, флаг може да се поддържа, за да се определи повторното изпълнение на процеса на сортиране. Флагът трябва да бъде зададен на false, когато не са необходими други суапове.
Код:
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. Сортиране на вмъкване
В Insertion сортирането на механизма за сортиране се осъществява чрез изграждане на сортиран масив с един елемент наведнъж. елементите на масива се сравняват последователно и след това се пренареждат в един конкретен ред. Компонентите на масива се сравняват последователно с всеки от елементите и след това се подреждат едновременно в определен ред. Използваната тук аналогия е много подобна на подреждането на набор от карти.
Код:
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. Сливане на сортиране
Сортирането на Merge работи на принципа на разделяне и завладява алгоритъма. Тук даденият вход се разделя на две половини и сплетените половини се сортират и след това се сливат. При възприятието на питон функцията merge () се използва за постигане на процеса на сливане. алгоритъмът за сортиране на вмъкване е като по-долу,
- Споменатият масив трябва да бъде разделен на две различни части и медианата на масива е определена за това.
- Сливане сортиране се прилага през първата половина на разделянето.
- Тогава втората половина също е изложена на същото.
- Най-сетне след сортирането отделените половини се сливат.
Код:
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. Heap Sort
Heap сортирането е форма на техника за сортиране на селекция. Тя включва отделяне на дадения вход като подредени и несортирани елементи. След това алгоритъмът циклира по този начин върху несортираната област, така че във всеки цикъл най-голямата стойност ще бъде изтласкана в сортирания регион. Този процес ще бъде продължен във всички елементи в несортирания регион.
От дадения списък за въвеждане се създава максимална купчина. Последната стойност се замества с първата стойност многократно и също така диапазонът на стойностите се намалява сравнително с една. Този процес протича, докато обхватът се свие до 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. Сортиране на Radix
Radix sort е техника за сортиране, която напредва, без да сравнява въведените елементи. Това се постига чрез генериране на кофа според стойността на радикса за елементи с повече от една цифра, включваща техниката, която се прилага за всички цифри в елемента. Нарича се също като вид на кофата. Тази техника за сортиране е твърде бърза в подходящата им среда.
Код:
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)
изход:
заключение
За определен период от време съществуват множество алгоритми, предназначени за сортиране на входния набор. Те бяха проектирани с мотото за постигане на по-добра техника и оптимизирано изпълнение в процеса на сортиране. Някои от най-ключовите са разгледани по-горе. От гледна точка на python този език се откроява като много гъвкав и стабилен език за разработването на тези алгоритми.
Препоръчителни статии
Това е Ръководство за сортиране на алгоритми в Python. Тук обсъждаме въвеждането и топ 6 алгоритми за сортиране в python, заедно с реализацията му на код. Можете също да разгледате следните статии, за да научите повече-
- Обръщане на числото по различни начини в Python
- Различни видове алгоритми за маршрутизиране
- Видове парцели в Matplotlib в Python
- Топ 14 Tuples в Python