Introdução aos algoritmos de classificação em Python
A classificação é um processo de reorganizar os elementos em alguma ordem para que o processamento adequado possa ser aplicado a ele. a classificação se torna necessária porque, na maioria dos casos, os dados recuperados da fonte permanecem mal ordenados. Para triunfar sobre isso, vários algoritmos de classificação foram criados ao longo dos anos. vamos discutir brevemente alguns dos principais algoritmos de classificação usados na programação em python.
Os 6 principais algoritmos de classificação em Python
Abaixo estão os diferentes algoritmos de classificação para python:
1. Classificação por bolhas
A classificação por bolha está entre as técnicas de classificação mais usadas, a partir dos dois primeiros pares de elementos, ela envolve a classificação de uma série de elementos, comparando todos os pares adjacentes de elementos. portanto, quando uma ordem desalinhada é estabelecida, ocorre a troca de elementos. Até que o último elemento no conjunto de entrada o processo acima continue perceptivelmente, para otimizar o algoritmo, pedimos para interrompê-lo depois que a classificação for concluída. Como descobriremos que concluímos a classificação? isso pode ser determinado quando todos os itens estão em ordem. Portanto, sempre que as variáveis são trocadas, um sinalizador pode ser mantido para determinar a reexecução do processo de classificação. O sinalizador deve ser definido como falso quando nenhum outro swap for necessário.
Código:
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))
Resultado:
2. Seleção da Seleção
A classificação por seleção está entre as técnicas de classificação mais básicas. Essa técnica envolve encontrar o elemento mínimo ou mínimo do conjunto não classificado e posicionar esse elemento no início do conjunto não classificado. Ao fazer um loop dessas operações em todos os elementos do conjunto, é possível obter um conjunto completamente classificado. O algoritmo separa a lista de chaves conectada em duas partes diferentes. A lista interna ou a lista de assinaturas tendem a já ser classificadas, o que envolve a geração do elemento mais à esquerda para o elemento mais à direita e a sublista de itens pendentes a serem classificados que habitam a pausa da lista. Inicialmente, a sub-lista classificada não é preenchida e a sub-lista não classificada é a lista de chaves completa.
Código:
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))
Resultado:
3. Classificação de Inserção
Na classificação por inserção, o mecanismo de classificação é realizado através da construção de uma matriz classificada com um item de cada vez. os elementos da matriz são comparados de maneira seqüencial e depois reorganizados em uma ordem específica. Os componentes da matriz são comparados sequencialmente com cada um dos elementos e, em seguida, ordenados simultaneamente em uma ordem específica. A analogia usada aqui é muito semelhante à organização de um conjunto de cartões.
Código:
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))
Resultado:
4. Mesclar Classificação
A classificação Merge funciona com base no princípio do algoritmo de divisão e conquista. Aqui, a entrada fornecida é emendada em duas metades e as metades emendadas são classificadas e depois mescladas. Na percepção de python, a função merge () é usada para alcançar o processo de mesclagem. o algoritmo para classificação de inserção é como abaixo,
- A matriz mencionada precisa ser dividida em duas partes diferentes e a mediana da matriz é determinada para isso.
- A classificação de mesclagem é aplicada na primeira metade da divisão.
- Então a segunda metade também é exposta à mesma.
- Por fim, após a classificação, as metades segregadas são mescladas.
Código:
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)
Resultado:
5. Heap Sort
A classificação de heap é uma forma de técnica de classificação de seleção. Envolve a segregação da entrada fornecida como elementos classificados e não classificados. Então o algoritmo faz um loop dessa maneira na região não classificada, de modo que em cada loop o maior valor seja empurrado para a região classificada. Esse processo será continuado em todos os elementos da região não classificada.
Um heap máximo é criado a partir da lista de entrada fornecida. O último valor é então trocado com o primeiro valor repetidamente e também a faixa de valores é comparativamente reduzida em um. Esse processo ocorre até que o intervalo diminua para 1.
Código:
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))
Resultado:
6. Classificação Radix
A classificação Radix é uma técnica de classificação que progride sem comparar os elementos digitados. Isso é obtido por meio da geração de um bucket de acordo com o valor do radix para elementos com mais de um dígito envolvido, a técnica é aplicada a todos os dígitos do elemento. Também é denominado como classificação de balde. Essa técnica de classificação tende a ser muito rápida em seus ambientes adequados.
Código:
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)
Resultado:
Conclusão
Durante um período de tempo, houve vários algoritmos projetados para classificar o conjunto de entradas. Eles foram projetados com o lema de alcançar melhores técnicas e execução otimizada no processo de classificação. Alguns dos mais importantes são discutidos acima. Da perspectiva do python, essa linguagem se destaca por ser uma linguagem muito flexível e estável para a criação desses algoritmos.
Artigos recomendados
Este é um guia para classificar algoritmos em Python. Aqui discutimos a introdução e os 6 principais algoritmos de classificação em python, juntamente com sua implementação de código. Você também pode consultar os seguintes artigos para saber mais:
- Invertendo o número usando maneiras diferentes em Python
- Vários tipos de algoritmos de roteamento
- Tipos de plotagem em Matplotlib em Python
- As 14 melhores tuplas em Python