Programa de Python para ordenar por fusión

Como un lenguaje de programación multiparadigma con un enfoque de diseño estructurado y orientado a objetos y sintaxis y gramática simples y ordenadas, Python está emergiendo rápidamente como el lenguaje de elección para los programadores que trabajan en proyectos de diversa complejidad y escala.

Python proporciona una biblioteca modular de algoritmos preconstruidos que permite a sus usuarios realizar varias operaciones que pueden ayudarlos a lograr su tarea por sí mismos o servir como un paso en el camino para lograr un objetivo más grande y complejo. Uno de los algoritmos de este tipo más populares es el que habilita la funcionalidad Merge Sort.

¿Qué es la ordenación por combinación?

Es una técnica de clasificación de propósito general que permite a los usuarios tomar un conjunto de datos aleatorio de cualquier tipo y de cualquier fuente y dividirlo en etapas repetitivas hasta que finalmente se descomponga en sus componentes individuales: una técnica recursiva, comúnmente conocida como ' método divide y vencerás.

Luego, el algoritmo reúne los componentes individuales, nuevamente en etapas repetitivas, pero los clasifica en una secuencia lógica predeterminada en cada etapa del camino, utilizando la comparación básica y el intercambio hasta que toda la serie de datos se reconstituye en la secuencia lógica deseada. .

Consulte nuestros otros cursos de ciencia de datos en upGrad.

Técnica divide y vencerás

Tomemos, por ejemplo, un conjunto de datos aleatorios de letras del alfabeto: N, H, V, B, Q, D, Z, R.

Paso 1 : el conjunto de datos original primero se divide en dos grupos de la siguiente manera:

N, H, V, B Q, D, Z, R

Paso 2 : Ambas matrices resultantes se subdividen de la siguiente manera:

N, H V, B Q, D Z, R

Paso 3 : Finalmente, los cuatro arreglos se escupen más hasta que toda la serie de datos se desglosa en sus componentes individuales:

N H V B Q D Z R

Luego, el proceso se invierte y los puntos de datos individuales ahora comienzan a fusionarse por etapas. Pero en el transcurso de este proceso de fusión, cada elemento en cada subarreglo se evalúa y se intercambia para que se ordenen en una secuencia lógica (orden alfabético), de la siguiente manera:

Paso 4 : Los elementos individuales se fusionan en pares mientras intercambian posiciones según sea necesario para formar la secuencia correcta:

H, N B, V D, Q R, Z

Paso 5 : el proceso recursivo de fusión y clasificación continúa en la siguiente iteración:

B, H, N, V ​​D, Q, R, Z

Paso 6 : toda la serie de datos finalmente se reconstituye en su orden alfabético lógico:

B, D, H, N, Q, R, V, Z

Explore nuestros cursos populares de ciencia de datos

Implementaciones de clasificación por combinación

Hay dos enfoques para la implementación de Merge Sort en Python. El enfoque de arriba hacia abajo y el enfoque de abajo hacia arriba.

Enfoque de arriba hacia abajo:

El enfoque de arriba hacia abajo más utilizado es el descrito anteriormente. Lleva más tiempo y utiliza más memoria y, por lo tanto, es ineficiente cuando se trabaja con conjuntos de datos más pequeños. Sin embargo, es mucho más confiable, particularmente cuando se aplica a grandes conjuntos de datos.

Lea nuestros populares artículos de ciencia de datos

Codigo de entrada:

def merge_sort (inp_arr):

tamaño = len(inp_arr)

si tamaño > 1:

medio = tamaño // 2

izquierda_arr = inp_arr(:medio)

rIght_arr = inp_arr(centro:)

merge_sort(left_arr)

fusionar _ordenar (right_arr)

yo = 0

j = 0

k = 0

(Donde i y j son los iteradores para recorrer las mitades izquierda y derecha de la serie de datos, respectivamente, y k es el iterador de la serie de datos general).

tamaño_izquierda = len(arr_izquierda)

tamaño_derecho = len(arr_derecho)

mientras que i < tamaño_izquierdo y j < tamaño derecho:

si matriz_izquierda(i) < matriz_derecha (j):

inp_arr(k) – left_arr(i)

yo >= 1

más:

inp_arr(k) = right_arr (j)

j += 1

k += 1

while i < tamaño_izquierda:

entrada_arr (k) = izquierda_arr(i)

yo += 1

k += 1

while j < tamaño_derecho:

inp_arr (k) = right_arr(j)

j += 1

k += 1

inp_arr = (N, H, V, B, Q, D, Z, R)

imprimir (: Matriz de entrada: \ n ")

imprimir(inp_arr)

merge_sort (inp_arr)

imprimir ("Matriz ordenada:\n")

imprimir (inp_arr)

Producción:

Matriz de entrada: N, H, V, B, Q, D, Z, R

Matriz de salida: B, D, H, N, Q, R, V, Z

Enfoque de abajo hacia arriba:

El enfoque de abajo hacia arriba es más rápido, usa menos memoria y funciona de manera eficiente con conjuntos de datos más pequeños, pero puede tener problemas cuando se trabaja con conjuntos de datos grandes. Por lo tanto, se usa con menos frecuencia.

Codigo de entrada:

def fusionar (izquierda, derecha):

resultado = [] x, y = 0, 0

para k en el rango (0, len (izquierda) + len (derecha)):

if i == len(izquierda): # si al final de la primera mitad,

result.append(right[j]) # suma todos los valores de la segunda mitad

j += 1

elif j == len(derecha): # si al final de la segunda mitad,

result.append(left[x]) # suma todos los valores de la primera mitad

yo += 1

elif derecha[j] < izquierda[i]:

resultado.append(derecha[j])

j += 1

más:

resultado.append(izquierda[i])

yo += 1

resultado devuelto

def mergesort(ar_list):

longitud = len(ar_list)

tamaño = 1

mientras que tamaño <longitud:

size+=size # se inicializa en 2 como se describe

para pos en rango (0, longitud, tamaño):

comienzo = posición

mid = pos + int(tamaño / 2)

final = pos + tamaño

izquierda = ar_list[ inicio : medio ] derecha = ar_list[ medio : fin ]

ar_list[inicio:final] = fusionar(izquierda, derecha)

volver ar_list

lista_ar = [N, H, V, B, Q, D, Z, R] imprimir (combinar ordenación (lista_ar))

Producción:

Matriz de entrada: N, H, V, B, Q, D, Z, R

Matriz de salida: B, D, H, N, Q, R, V, Z

Implementación de Merge Sort aplicada a conjuntos de datos más complejos de la vida real

Apliquemos el enfoque de arriba hacia abajo a cuatro vehículos todoterreno aleatorios en India:

Codigo de entrada:

Coche de clase :

def __init__(uno mismo, marca, modelo, precio):

self.marca = marca

self.modelo = modelo

self.precio = precio

def __str__(uno mismo):

return str.format(“Marca: {}, Modelo: {}, Precio: {}”, self.brand,

auto.modelo, auto.precio)

def fusionar(lista1, i, j, k, comp_fun):

copia_izquierda = lista1[i:k + 1]

r_sublista = lista1[k+1:r+1]

índice_copia_izquierda = 0

j_sublista_índice = 0

índice_ordenado = yo

while left_copy_index < len(left_copy) andj_sublist_index <

len(j_sublista):

if comp_fun(left_copy[left_copy_index], j_sublist[j_sublist_index]):

lista1[índice_ordenado] = copia_izquierda[índice_copia_izquierda]

índice_copia_izquierda = índice_copia_izquierda + 1

más :

lista1[índice_ordenado] = j_sublista[j_sublista_índice]

j_sublist_index = j_sublist_index + 1

índice_ordenado = índice_ordenado + 1

while copia_izquierda_índice < len(copia_izquierda):

lista1[índice_ordenado] = copia_izquierda[índice_copia_izquierda]

índice_copia_izquierda = índice_copia_izquierda + 1

índice_ordenado = índice_ordenado + 1

while j_sublist_index < len(j_sublist):

lista1[índice_ordenado] = j_sublista[j_sublista_índice]

j_sublist_index = j_sublist_index + 1

índice_ordenado = índice_ordenado + 1

def merge_sort(lista1, i, j, comp_fun):

si yo >= j:

retorno

k = (i + j)//2

merge_sort(lista1, i, k, comp_fun)

merge_sort(lista1, k + 1, j, comp_fun)

fusionar (lista1, i, j, k, comp_fun)

coche1 = Coche(“Jeep”, “Wrangler”, 0.58)

coche2 = Coche(“Ford”, “Endeavour”, 0.35)

coche3 = Coche(“Jaguar Land Rover”, “Range Rover Sport”, 1.76)

coche4 = Coche(“Mercedes Benz”, “Clase G”, 2.42)

lista1 = [coche1, coche2, coche3, coche4]

merge_sort(lista1, 0, len(lista1) -1, lambda cocheA, cocheB: cocheA.marca < cocheB.marca)

print ("Coches ordenados por marca:")

para coche enlist1:

imprimir (coche)

imprimir ()

merge_sort(lista1, 0, len(lista1) -1, lambda cocheA, cocheB: cocheA.precio< cocheB.precio)

print ("Coches ordenados por precio:")

para coche enlist1:

imprimir (coche)

Producción:

Coches ordenados por marca:

Ford esfuerzo

jaguar land rover gama rover deporte

Jeep Wrangler

Mercedes Benz clase G

Coches ordenados por precio:

Ford esfuerzo

Jeep Wrangler

jaguar land rover gama rover

Mercedes Benz clase G

Puede aprender aspectos tanto teóricos como prácticos de Python con el Certificado profesional de upGrad en ciencia de datos y análisis empresarial de la Universidad de Maryland. Este curso te ayuda a aprender Python desde cero. Incluso si eres nuevo en la programación y la codificación, upGrad te ofrecerá un curso preparatorio de dos semanas para que puedas aprender los conceptos básicos de la programación. aprenderá sobre varias herramientas como Python, SQL, mientras trabaja en múltiples proyectos de la industria.

¡Planifique su carrera de desarrollo de software ahora!

Solicite el programa de certificado profesional en ciencia de datos y análisis empresarial