Introducción a la clasificación de algoritmos en Python
La clasificación es un proceso de reorganización de los elementos en algún orden para que se le pueda aplicar un procesamiento adecuado. la clasificación se hace necesaria porque, en la mayoría de los casos, los datos recuperados de la fuente siguen estando mal ordenados. Para triunfar sobre esto, se crearon varios algoritmos de clasificación a lo largo de los años. Discutamos brevemente algunos de los algoritmos de clasificación de claves que se utilizan con la programación de Python.
Los 6 mejores algoritmos de clasificación en Python
A continuación se muestran los diferentes algoritmos de clasificación para python:
1. Ordenar burbujas
La clasificación de burbujas es una de las técnicas de clasificación más utilizadas, comenzando por los dos primeros pares de elementos, implica ordenar una serie de elementos comparando cada par de elementos adyacentes. entonces, cuando se establece un orden desalineado, se produce el intercambio de elementos. Hasta que el último elemento en el conjunto de entrada se continúe perceptiblemente el proceso anterior, para optimizar el algoritmo, solicitamos detenerlo después de que haya completado la clasificación. ¿Cómo podemos distinguir que hemos completado la clasificación? esto podría determinarse cuando todos los elementos dados estén en orden. Por lo tanto, cada vez que se intercambian variables, se puede mantener un indicador para determinar la re-ejecución del proceso de clasificación. El indicador debe establecerse en falso cuando no se necesitan otros intercambios.
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))
Salida:
2. Selección de selección
La clasificación por selección es una de las técnicas de clasificación más básicas. Esta técnica implica encontrar el elemento mínimo o mínimo del conjunto sin clasificar y posicionar ese elemento al comienzo del conjunto sin clasificar. Al recorrer estas operaciones en todos los elementos del conjunto, se puede lograr un conjunto completamente ordenado. El algoritmo segrega la lista de claves enganchada en dos partes diferentes. La lista interna o la lista de suscripción tienden a estar ya ordenadas, lo que implica generar desde el elemento más a la izquierda hasta el elemento más a la derecha, y la sublistación de elementos pendientes de clasificar que habitan en el relevo de la lista. Al principio, la sublista ordenada no está llena y la sublista no ordenada es la lista de claves 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))
Salida:
3. Ordenar por inserción
En la ordenación por inserción, el mecanismo de ordenación se lleva a cabo creando una matriz ordenada con un elemento a la vez. Los elementos de la matriz se comparan de forma secuencial y luego se reorganizan en un orden específico. Los componentes de la matriz se comparan secuencialmente con cada uno de los elementos y luego se ordenan simultáneamente en un orden específico. La analogía utilizada aquí es muy similar a organizar un conjunto de tarjetas.
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))
Salida:
4. Combinar Ordenar
La clasificación de combinación funciona según el principio del algoritmo de división y conquista. Aquí la entrada dada se empalma en dos mitades y las mitades empalmadas se ordenan y luego se fusionan. En la percepción de Python, la función merge () se usa para lograr el proceso de fusión. El algoritmo para la ordenación por inserción es el siguiente,
- La matriz mencionada debe dividirse en dos partes diferentes y la mediana de la matriz se determina para esto.
- La ordenación por fusión se aplica en la primera mitad de la división.
- Entonces la segunda mitad también está expuesta a lo mismo.
- Por fin, después de ordenar, las mitades segregadas se fusionan.
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)
Salida:
5. Heap Sort
La ordenación del montón es una forma de técnica de selección y selección. Implica segregar la entrada dada como elementos ordenados y no ordenados. Luego, el algoritmo realiza un bucle de tal manera en la región no ordenada, de modo que en cada bucle el valor más grande será empujado hacia la región ordenada. Este proceso continuará en todos los elementos de la región sin clasificar.
Se crea un montón máximo a partir de la lista de entrada dada. El último valor se intercambia con el primer valor repetidamente y también el rango de valores se reduce comparativamente en uno. Este proceso tiene lugar hasta que el rango se reduce a 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))
Salida:
6. Clasificación de radix
La clasificación por radix es una técnica de clasificación que progresa sin comparar los elementos introducidos. Esto se logra mediante la generación de un depósito de acuerdo con el valor de la raíz para elementos con más de un dígito involucrado, la técnica se aplica a todos los dígitos del elemento. También se denomina clasificación de cubo. Esta técnica de clasificación tiende a ser demasiado rápida en sus entornos adecuados.
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)
Salida:
Conclusión
Durante un período de tiempo, hubo numerosos algoritmos diseñados para clasificar el conjunto de entrada. Fueron diseñados con el lema de lograr una mejor técnica y una ejecución optimizada en el proceso de clasificación. Algunos de los más importantes se analizan anteriormente. Desde la perspectiva de Python, este lenguaje se destaca por ser un lenguaje muy flexible y estable para diseñar estos algoritmos.
Artículos recomendados
Esta es una guía para ordenar algoritmos en Python. Aquí discutimos la introducción y los 6 mejores algoritmos de clasificación en Python junto con su implementación de código. También puede consultar los siguientes artículos para obtener más información.
- Invertir el número usando diferentes formas en Python
- Varios tipos de algoritmos de enrutamiento
- Tipos de parcelas en Matplotlib en Python
- Las 14 mejores tuplas en Python