Saltar al contenido
Home » Ordenación por Fusión

Ordenación por Fusión

El altgoritmo de ordenación por fusión es un enfoque más sofisticado para organizar elementos en un arreglo. Aunque puede ser más complejo que otros métodos, el ordenamiento por fusión es altamente eficiente y se utiliza en muchas aplicaciones. En este artículo, exploraremos a fondo el algoritmo de ordenación por fusión en Java, proporcionando un ejemplo de programación acompañado de comentarios explicativos.

Introdución 

El algoritmo de ordenación por fusión utiliza una estrategia «divide y conquista». Divide el arreglo en dos mitades, ordena cada mitad y luego fusiona las mitades ordenadas para obtener el arreglo final ordenado. Aunque puede requerir más operaciones en comparación con otros algoritmos, su eficiencia y estabilidad lo convierten en una opción popular para grandes conjuntos de datos y aplicaciones críticas.

Ejemplo de Programacion

A continuación, presentamos un ejemplo de implementación del algoritmo de ordenación por fusión en Java, junto con comentarios que explican cada paso:

				
					 import java.util.Arrays;
public class MergeSort {
    public static void main(String[] args) {
        int[] arreglo = {5, 2, 9, 1, 5, 6};
        System.out.println("Arreglo original: " + Arrays.toString(arreglo));
        mergeSort(arreglo, 0, arreglo.length - 1);
        System.out.println("Arreglo ordenado: " + Arrays.toString(arreglo));
    }
    // Función principal de ordenación por fusión
    public static void mergeSort(int[] arreglo, int izquierda, int derecha) {
        if (izquierda < derecha) {
            int medio = izquierda + (derecha - izquierda) / 2;
            
            // Llamada recursiva para ordenar la mitad izquierda
            mergeSort(arreglo, izquierda, medio);
            
            // Llamada recursiva para ordenar la mitad derecha
            mergeSort(arreglo, medio + 1, derecha);
            
            // Combinaci&#xF3;n de las mitades ordenadas
            merge(arreglo, izquierda, medio, derecha);
        }
    }
    // Funci&#xF3;n de combinaci&#xF3;n de las mitades ordenadas
    public static void merge(int[] arreglo, int izquierda, int medio, int derecha) {
        int n1 = medio - izquierda + 1;
        int n2 = derecha - medio;
        int[] arregloIzq = new int[n1];
        int[] arregloDer = new int[n2];
        // Copiar datos a los arreglos temporales
        for (int i = 0; i < n1; i++) {
            arregloIzq[i] = arreglo[izquierda + i];
        }
        for (int j = 0; j < n2; j++) {
            arregloDer[j] = arreglo[medio + 1 + j];
        }
        int i = 0, j = 0, k = izquierda;
        
        // Combinar los arreglos temporales de manera ordenada
        while (i < n1 && j < n2) {
            if (arregloIzq[i] <= arregloDer[j]) {
                arreglo[k] = arregloIzq[i];
                i++;
            } else {
                arreglo[k] = arregloDer[j];
                j++;
            }
            k++;
        }
        // Copiar los elementos restantes de arregloIzq, si los hay
        while (i < n1) {
            arreglo[k] = arregloIzq[i];
            i++;
            k++;
        }
        // Copiar los elementos restantes de arregloDer, si los hay
        while (j < n2) {
            arreglo[k] = arregloDer[j];
            j++;
            k++;
        }
    }
}

				
			

Comentarios Explicativos

  • El arreglo es el arreglo que queremos ordenar.
  • mergeSort es la función que implementa el algoritmo de ordenación por fusión.
  • El primer bucle for exterior divide el arreglo en mitades.
  • medio es el índice del elemento medio del arreglo.
  • La función merge fusiona las dos mitades ordenadas en un solo arreglo ordenado.
  • Los bucles while dentro de merge realizan la fusión de las mitades y ordenan los elementos.

Conclución 

El algoritmo de ordenación por fusión es una elección excelente para ordenar grandes conjuntos de datos. Aunque su implementación puede ser más compleja, su eficiencia y estabilidad lo convierten en una herramienta valiosa en muchas aplicaciones. Al comprender cómo el algoritmo divide, ordena y fusiona los elementos, los desarrolladores pueden adquirir habilidades esenciales para trabajar con algoritmos de ordenación más avanzados y resolver problemas de programación más desafiantes.
Etiquetas: