Implemente varios métodos de clasificación clásicos en Python
'''
La operación básica de clasificación por inserción es insertar datos en los datos ordenados para obtener un nuevo número más uno. Para datos secuenciales, este algoritmo. es adecuado para ordenar una pequeña cantidad de datos y la complejidad del tiempo es O (n ^ 2). Es un método de clasificación estable.
El algoritmo de inserción divide la matriz a ordenar en dos partes:
La primera parte contiene todos los elementos de la matriz excepto el último elemento (esto le da a la matriz una ranura de inserción más espacio)
La segunda parte solo contiene este elemento (el elemento que se insertará).
Después de ordenar la primera parte, inserte el último elemento en la primera parte ordenada.
'''
def insert_sort(listas):
# insert_sort
count = len(listas)
para i en rango(1, recuento):
clave = listas[i]
j = i - 1
mientras j gt = 0 :
if listas[j] gt; clave:
listas[j 1] = listas[j]
listas[j] = clave
j -= 1
listas de retorno
'' '
La ordenación Shell es una especie de ordenación por inserción. Es una versión más eficiente y mejorada del algoritmo de clasificación por inserción directa. Shell sort es un algoritmo de clasificación no estacionario. Lleva el nombre de DL.Shell, que fue propuesto en 1959.
La clasificación Shell agrupa los registros por incremento de subíndice y utiliza el algoritmo de clasificación por inserción directa para ordenar cada grupo; a medida que el incremento disminuye, cada grupo contiene más y más palabras clave. Cuando el incremento disminuye a 1, el algoritmo termina y. todo el archivo está agrupado.
'''
def shell_sort(lists):
# Hill sort
count = len(lists)
paso = 2
grupo = recuento/paso
mientras grupo gt.0:
para i en rango(0, grupo): p>
j = i grupo
mientras j lt; cuenta:
k = j - grupo
clave = listas[j]
mientras k gt; = 0:
if listas[k] gt; clave:
listas[k grupo] = listas[k]
listas[k] = clave
k -= grupo
j = grupo
grupo /= paso
devolver listas
'''
La clasificación burbujeante itera repetidamente sobre la matriz que se va a ordenar, comparando dos elementos cada vez e intercambiándolos si están en el orden incorrecto. Itere sobre la matriz repetidamente hasta que no se necesiten más intercambios, lo que significa que la matriz está ordenada.
'''
def bubble_sort(lists):
# clasificación de burbujas
count = len(lists)
para i en rango(0, recuento):
para j en rango(i 1, recuento):
if listas[i] gt;
temp = listas[j]
listas[j] = listas[i]
listas[i] = temporal
retorno listas
'''
resultado = right[j:]
devolver resultado
def merge_sort(listas):
# Combinar orden
si len(lists) lt;= 1:
devolver listas
num = len(lists) / 2
izquierda = merge_sort(listas[:num])
derecha = merge_sort(listas[num:])
devolver fusionar(izquierda, derecha)
''''
La clasificación Radix es una clasificación por distribución, también conocida como clasificación por cubos o clasificación por contenedores. Como sugiere el nombre, asigna los elementos que se van a clasificar en ciertos "depósitos" a través de partes clave de la información para lograr el efecto de clasificación. Su método de clasificación básico es la clasificación estable.
La complejidad del tiempo es O (nlog(r)m), donde r es la base tomada y m es el número de montones. En ciertos momentos, la clasificación por base es más eficiente que otras clasificaciones estables.
'''
importar matemáticas
def radix_sort(lists, radix=10):
k = int(math.ceil (math.log(max(lists), radix)))
bucket = [ [] for i in range(radix)]
for i in range(1, k 1 ):
para j en listas:
bucket[j/(radix**(i-1)) (radix**i)].append(j)
dellists[:]
para z en el depósito:
lists = z
del z[:]
listas de devolución
---------------------
Autor: CRazyDOgen
Fuente: CSDN
Artículo original:/jipang6225/article/details/79975312
Copyright: este artículo es un artículo original del blogger. Indique el enlace de la publicación del blog al reimprimir.