Introducción a Merge Sort en Java
Program for Merge Sort en Java es uno de los algoritmos más utilizados y eficientes. La ordenación por fusión se basa en la técnica de dividir y conquistar que consiste en dividir un problema dado en múltiples subproblemas y resolver cada subproblema de forma independiente. Cuando se resuelven los subproblemas, combinamos sus resultados para obtener la solución final al problema. El algoritmo de ordenamiento por fusión se puede implementar utilizando la recursividad, ya que implica trabajar con subproblemas en lugar del problema principal.
¿Cómo funciona Merge Sort?
Consideremos una matriz sin clasificar que necesita ser ordenada usando el algoritmo de clasificación de fusión. Estos son los pasos necesarios para ordenar una matriz con valores: 18, 8, 4, 13, 10, 12, 7 y 11:
- El primer paso consiste en encontrar un elemento pivote en base al cual nuestra matriz de entrada se dividirá en submatrices.
- Consideremos que el elemento 13 se elige como pivote, por lo tanto, la matriz original se dividirá en dos submatrices. El primer subconjunto contendrá 18, 8, 4, 13 y el segundo subconjunto contendrá los elementos restantes 10, 12, 7, 11.
- Las submatrices obtenidas en el paso 2 se subdividen adicionalmente como en el paso 1 y esto continúa.
- Una vez que la matriz principal se divide en subconjuntos con elementos individuales, comenzamos a fusionar estos subconjuntos nuevamente de modo que los elementos combinados estén ordenados.
- Así es como funciona la división y conquista reales:
Programa para Ordenar Fusiones en Java
Aquí hay un ejemplo de código que muestra la implementación de la ordenación por fusión en Java:
Código:
package com.edubca.sorting;
public class MergeSort (
private int() array;
private int() tempMergedArr;
private int length;
public static void main(String a())(
int() inputArr = (18, 8, 4, 13, 10, 12, 7, 11);
MergeSort mergeSort = new MergeSort();
mergeSort.sort(inputArr);
for(int i:inputArr)(
System.out.print(i + " ");
)
)
public void sort(int inputArr()) (
this.array = inputArr;
this.length = inputArr.length;
this.tempMergedArr = new int(length);
performMergeSort(0, length - 1);
)
private void performMergeSort(int lowerIndex, int higherIndex) (
if (lowerIndex < higherIndex) (
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Sort the left side of the array call performMergeSort recursively
performMergeSort(lowerIndex, middle);
// Sort the right side of the array call performMergeSort recursively
performMergeSort(middle + 1, higherIndex);
// Merge subparts using a temporary array
mergeData(lowerIndex, middle, higherIndex);
)
)
private void mergeData (int lowerIndex, int middle, int higherIndex) (
for (int i = lowerIndex; i <= higherIndex; i++) (
tempMergedArr(i) = array(i);
)
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) (
if (tempMergedArr(i) <= tempMergedArr(j)) (
array(k) = tempMergedArr(i);
i++;
) else (
array(k) = tempMergedArr(j);
j++;
)
k++;
)
while (i <= middle) (
array(k) = tempMergedArr(i);
k++;
i++;
)
)
)
El código anterior producirá una matriz ordenada como salida.
Salida:
¿Cuándo deberíamos usar el tipo de combinación?
La ordenación por fusión se puede usar en los siguientes escenarios:
- Cuando la estructura de datos que se va a ordenar no admite el acceso aleatorio, la ordenación por fusión puede ser útil y eficiente.
- Cuando se requiere un alto nivel de paralelismo, se puede usar la clasificación de fusión ya que se pueden resolver diferentes subproblemas de forma independiente utilizando múltiples procesos que se ejecutan en paralelo.
- La ordenación por fusión es más rápida cuando se trabaja con listas vinculadas porque los punteros se pueden cambiar fácilmente al fusionar las listas.
- La ordenación por fusión se puede considerar como una ordenación estable, lo que significa que el mismo elemento en una matriz mantiene sus posiciones originales entre sí. En los casos en que se requiere una alta estabilidad, se puede optar por la fusión.
Análisis de complejidad del ordenamiento por fusión
A continuación se detalla la complejidad del análisis del tipo de fusión:
- La ordenación por fusión es un algoritmo recursivo y su complejidad temporal es O (n * log n) en los tres casos (peor, mejor y promedio), ya que la ordenación por fusión divide la matriz en dos mitades iguales y toma un tiempo lineal para fusionarlas.
- La complejidad espacial del tipo de fusión es O (n) ya que opera en el enfoque recursivo. Por lo tanto, la ordenación por fusión puede considerarse como un algoritmo rápido, espacial y eficiente en el tiempo.
Comparar el orden de fusión con otros algoritmos
Los siguientes puntos comparan el orden de fusión con otros algoritmos:
- Heap Sort tiene la misma complejidad de tiempo que merge sort, pero solo requiere espacio auxiliar O (1) en lugar de merge sort's O (n). Por lo tanto, el ordenamiento dinámico es más eficiente en espacio que el ordenamiento combinado.
- Las implementaciones de ordenación rápida generalmente superan a la ordenación por fusión para ordenar las matrices basadas en RAM.
- La ordenación por fusión supera los algoritmos de ordenación rápida y ordenación en montón cuando se trabaja con la lista vinculada, ya que los punteros se pueden cambiar fácilmente.
Conclusión-Programa para Merge Sort en Java
Del artículo, se concluye que el tipo de fusión es un concepto importante para entender cuando se trata de algoritmos.
Artículos recomendados
Esta es una guía para el Programa de clasificación de fusión en Java. Aquí discutimos cómo debería funcionar, su uso, el programa de Merge Sort, etc. También puede consultar nuestros otros artículos relacionados para obtener más información.
- Combinar Ordenar en Java
- Fusionar algoritmos de clasificación en Java
- Heap Sort en C
- Heap Ordenar en Java
- Herramientas de implementación de Java
- Heap Sort en Python
- Algoritmos de clasificación rápida en Java
- Los 6 mejores algoritmos de clasificación en JavaScript
- Los 6 mejores algoritmos de clasificación en Python