Guía Definitiva de Merge Sort: El Algoritmo de Divide y Vencerás

Juan Carlos Garcia Esquivel — Mon, 20 Apr 2026 16:26:09 +0000

Merge Sort es un algoritmo de ordenamiento basado en el paradigma Divide y Vencerás. Divide recursivamente el arreglo en mitades hasta llegar a elementos individuales (ordenados por definición) y luego los mezcla de forma ordenada. Garantiza un rendimiento de O(n log n) en todos los casos.

El algoritmo Merge Sort (u Ordenamiento por Mezcla) es uno de los pilares del ordenamiento en ciencias de la computación. Basado matemáticamente en el paradigma Divide y Vencerás, se destaca como una herramienta extremadamente poderosa cuando requerimos estabilidad y rendimiento garantizado.

En este artículo, exploraremos qué lo hace tan especial, cómo implementarlo de manera limpia y una táctica avanzada para optimizar su consumo de memoria en entornos de producción.

¿Qué es Merge Sort?

Su funcionamiento se divide en tres fases lógicas:

Divide: El algoritmo parte el arreglo a la mitad de forma recursiva hasta llegar a elementos individuales, los cuales se consideran ya ordenados.
Conquista (Conquer): Cada sub-división se resuelve y ordena de forma independiente.
Combina (Merge): Se unen o "mezclan" las piezas usando algoritmos de dos punteros (two-pointer technique), garantizando que las combinaciones resultantes sigan estando ordenadas.

A diferencia del popular QuickSort, Merge Sort siempre asegura una complejidad de tiempo de ejecución de O(n log n) en cualquier escenario (mejor caso, caso promedio y peor caso). Sin embargo, este rendimiento constante tiene un costo: mayor uso de la memoria RAM.

Visualización Paso a Paso

Para ver cómo el paradigma de "Divide y Vencerás" trabaja materialmente en un arreglo de ejemplo (n=6), te compartimos este mapa jerárquico del proceso de división.

Una vez reducidos a su mínima expresión matemática (n=1), el algoritmo comienza a ascender combinando (merge). Así es como una tabla de estado final interactúa entre un arreglo izquierdo (L) y derecho (R) utilizando Two-Pointers:

Implementación Básica en Go

A continuación, mostramos una implementación muy legible en Go. Este bloque se enfoca en que la lógica algorítmica sea directa y fácil de depurar:

func sortList(unsortedList []int) []int {
    n := len(unsortedList)
    if n <= 1 { return unsortedList }

    midpoint := n / 2
    leftList := sortList(unsortedList[:midpoint])
    rightList := sortList(unsortedList[midpoint:])

    resultList := make([]int, 0, n)
    leftPointer, rightPointer := 0, 0

    for leftPointer < midpoint || rightPointer < n-midpoint {
        if leftPointer == midpoint {
            resultList = append(resultList, rightList[rightPointer])
            rightPointer++
        } else if rightPointer == n-midpoint {
            resultList = append(resultList, leftList[leftPointer])
            leftPointer++
        } else if leftList[leftPointer] <= rightList[rightPointer] {
            resultList = append(resultList, leftList[leftPointer])
            leftPointer++
        } else {
            resultList = append(resultList, rightList[rightPointer])
            rightPointer++
        }
    }
    return resultList
}

Esta implementación es un excelente MVP (Minimum Viable Product). No obstante, un desarrollador experimentado notará rápidamente un área de oportunidad: hay una constante creación de sectores de memoria, o "slices". Crear un nuevo slice de tamaño n en cada ciclo invoca implícitamente la reserva de memoria dinámica, impactando el rendimiento global por la recolección de basura (Garbage Collector).

Optimización Clave: El Patrón de Búfer Compartido

Si se requiere una versión optimizada, destinada a librerías estándar o plataformas de alta escala, la mejor solución es el Patrón de Búfer Compartido (Shared Buffer Pattern).

Este enfoque se basa en asignar un único arreglo temp con capacidad para N elementos, antes de comenzar el proceso de recursividad. Ese temp sirve como fotocopiadora compartida. Las funciones solo leen desde ahí, reescribiendo la posición final directamente sobre los punteros iniciales de forma económica.

Observemos este modelo optimizado:

func SortList(arr []int) []int {
    if len(arr) <= 1 { return arr }

    // Un solo buffer auxiliar compartido para toda la ejecución
    temp := make([]int, len(arr))
    mergeSort(arr, temp, 0, len(arr)-1)
    return arr
}

func mergeSort(arr, temp []int, left, right int) {
    if left < right {
        mid := left + (right-left)/2

        mergeSort(arr, temp, left, mid)
        mergeSort(arr, temp, mid+1, right)

        merge(arr, temp, left, mid, right)
    }
}

func merge(arr, temp []int, left, mid, right int) {
    for i := left; i <= right; i++ { temp[i] = arr[i] }

    i, j, k := left, mid+1, left

    for i <= mid && j <= right {
        if temp[i] <= temp[j] {
            arr[k] = temp[i]
            i++
        } else {
            arr[k] = temp[j]
            j++
        }
        k++
    }

    for i <= mid {
        arr[k] = temp[i]
        i++; k++
    }
}

Gracias a esto, reducimos la memoria a O(N) estrictamente; sin importar cuántas uniones o subdivisiones ocurran, jamás excederemos el tamaño original del búfer. Esta técnica demuestra dominio sobre las estructuras de datos nativas y el manejo de recolección de basura.

Conclusión