diff --git a/conferences/2026/10-divide-y-venceras/presentacion.html b/conferences/2026/10-divide-y-venceras/presentacion.html new file mode 100644 index 0000000..8d61b19 --- /dev/null +++ b/conferences/2026/10-divide-y-venceras/presentacion.html @@ -0,0 +1,1643 @@ + + + + + +Conferencia 10: divide y vencerás + + + +
+ + +
+
Programación · MatCom · Conferencia 10 · 18 de noviembre de 2026
+

Partir, resolver, combinar

+

Proyecto de hoy: el millón de números que la conferencia 8 no pudo ordenar. Dos algoritmos nuevos, escritos en Python sin trucos, que lo ordenan en segundos.

+
+
+ + +
+
Dónde estamos
+

La 8 dejó una cuenta, la 9 una herramienta

+

La conferencia 8 terminó viendo que la selección, la inserción y la burbuja multiplican su trabajo por cuatro cada vez que la lista se duplica. La 9 nos dio la función que se llama a sí misma dos veces. Hoy juntamos las dos cosas.

+
+
7
Examen
el primer tema
+
8
Búsqueda, ordenación y costo
todas las palabras ordenadas, a mano
+
9
Recursión
las Torres de Hanói
+
10
Divide y vencerás
el millón de números
+ +
12
Evaluación
un problema de divide y vencerás
+
+
+ + +
+
El plan de la hora
+

De dos montones al millón

+ + + + + 1 · MEZCLAR + dos montones + cada elemento, una vez + + + 2 · POR MEZCLA + n log n + contado con el árbol + + + 3 · RÁPIDA + el pivote + y la lista que la rompe + + + 4 · EL RELOJ + contra la 8 + y contra sorted + + + + + + + un millón de números, en segundos + + +

Las partes 2 y 3 son dos maneras de seguir el mismo esquema, divide y vencerás: una trabaja al combinar y la otra al partir.

+
+ +
+
El proyecto
+

Diez horas contra un tercio de segundo

+
+
+
    +
  • En la conferencia 8, la selección ordenó 4000 números en 0,564 s.
  • +
  • Un millón es 4000 × 250. Si duplicar n multiplica por 4, multiplicar n por 250 multiplica el tiempo por 250² = 62 500.
  • +
  • 0,564 s × 62 500 ≈ 35 000 s: casi diez horas.
  • +
+

sorted ordena ese millón en 0,37 s. No es un n² escrito en un lenguaje más rápido: es otro algoritmo.

+
+
+
+
Selección, con un millón
+
Unos 500 000 millones de comparaciones: n(n − 1)/2. La estimación de diez horas sale del reloj de la conferencia 8.
+
+
+
sorted, con un millón
+
0,37 s, medido en este capítulo del libro. Al final de la hora escribimos dos de su familia y los ponemos al lado.
+
+
+
+
+ + +
+
Parte 1
+

Mezclar dos listas ordenadas

+

La pieza que no es recursiva. Todo lo demás se apoya en ella.

+
+ +
+
Dos montones de exámenes
+

El menor de todos está arriba de un montón

+
+
+
def mezclar(a, b):
+    resultado = []
+    i, j = 0, 0
+    while i < len(a) and j < len(b):
+        if a[i] <= b[j]:
+            resultado.append(a[i])
+            i += 1
+        else:
+            resultado.append(b[j])
+            j += 1
+    resultado.extend(a[i:])
+    resultado.extend(b[j:])
+    return resultado
+

Debajo del de arriba, todos son mayores. Por eso basta comparar los dos de arriba. Cuando un montón se acaba, el otro va entero al final.

+
+
+
+
de ade blos dos de arriba
+
+
+
+ +
+
Cuánto cuesta
+

Cada elemento se mira una vez

+
+
+
Las vueltas
+
Cada vuelta del while pone un elemento en resultado. Hay como mucho len(a) + len(b) vueltas.
+
+
+
Sin ciclo dentro de otro
+
La selección vuelve a recorrer lo que queda en cada vuelta. La mezcla coloca y no vuelve a tocar. Mezclar cuesta tanto como la cantidad de elementos.
+
+
+
El <=
+
Con dos iguales arriba, se toma primero el de a. Los iguales conservan su orden: es la estabilidad de la conferencia 8.
+
+
+

En la animación anterior, el escenario con iguales lo muestra: los 3 de a salen antes que el 3 de b.

+
+ +
+ En vivo · archivo mezcla.py +

Dos montones, un solo ciclo

+
+
+
def mezclar(a, b):
+    resultado = []
+    i, j = 0, 0                 # el de arriba de cada montón
+    while i < len(a) and j < len(b):
+        if a[i] <= b[j]:
+            resultado.append(a[i])
+            i += 1
+        else:
+            resultado.append(b[j])
+            j += 1
+    resultado.extend(a[i:])     # lo que quede de a
+    resultado.extend(b[j:])     # o lo que quede de b
+    return resultado
+
+
+print(mezclar([2, 5, 8, 9], [1, 3, 4, 10, 12]))
+ +
+
+
    +
  1. Antes de escribir: con dos montones boca arriba, ¿dónde puede estar el menor de todos? Arriba de uno de los dos.
  2. +
  3. Escribe mezclar con el aula. Dos índices, uno por montón.
  4. +
  5. ¿Cuántas vueltas da el while en el ejemplo? Siete: cuando b llega al 10, a ya se acabó.
  6. +
  7. ¿Y con mezclar([], [3, 4])? Ninguna vuelta: el extend copia b entera.
  8. +
+
+
+
+ + +
+
Parte 2
+

Ordenación por mezcla

+

Si sabes mezclar, ordenar es partir a la mitad, ordenar cada mitad y mezclar.

+
+ +
+
La recursión de la conferencia 9
+

Ordenar cada mitad es el mismo problema

+
+
+
def ordenar_mezcla(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    medio = len(lista) // 2
+    izquierda = ordenar_mezcla(lista[:medio])
+    derecha = ordenar_mezcla(lista[medio:])
+    return mezclar(izquierda, derecha)
+
    +
  • Caso base: cero o un elemento ya están ordenados.
  • +
  • Devuelve una lista nueva, como sorted. Por eso list(lista): una copia, no la misma lista con dos nombres (conferencia 4).
  • +
+
+
+
+

La animación mezcla en el mismo lugar para que se vea; el código construye listas nuevas. Lo apagado está fuera de la llamada actual.

+
+
+
+ +
+
El árbol de llamadas
+

Bajando parte, subiendo mezcla

+
+
+
    +
  • Bajando, cada llamada parte su lista a la mitad, hasta listas de un elemento.
  • +
  • Subiendo, cada nodo pasa a mostrar lo que devuelve: la mezcla de sus dos hijos.
  • +
  • A la derecha, cuántos elementos se mezclan en cada nivel.
  • +
+

¿Cuánto suma cada nivel?

+
+
+
+
+ +
+
Por qué es tan rápida
+

n por nivel, log₂ n niveles

+
+
+
+
Cada nivel mezcla n
+
Arriba, dos listas de 4 en una de 8. Abajo, cuatro mezclas de listas de 1. Los pedazos se achican, pero hay más: la suma es siempre la lista entera.
+
+
+
Hay log₂ n niveles
+
¿Cuántas veces se parte n a la mitad hasta llegar a 1? La pregunta de la búsqueda binaria: log₂ n. Con 8, tres niveles de mezclas.
+
+

Total: n log₂ n. Con un millón, n por 20, no n por un millón.

+
+
+
+

Comparaciones contadas en mezclar, con listas al azar. La mezcla hace algo menos que n log₂ n porque, cuando un montón se acaba, el otro se copia sin comparar.

+
+
+
+ +
+ En vivo · archivo mezcla.py, debajo de mezclar +

Probarla contra algo que sabemos que está bien

+
+
+
def ordenar_mezcla(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    medio = len(lista) // 2
+    izquierda = ordenar_mezcla(lista[:medio])
+    derecha = ordenar_mezcla(lista[medio:])
+    return mezclar(izquierda, derecha)
+
+
+print(ordenar_mezcla([38, 27, 43, 3, 9, 82, 10, 5]))
+
+random.seed(1)
+for prueba in range(500):
+    n = random.randint(0, 12)
+    original = [random.randint(1, 5) for _ in range(n)]
+    if ordenar_mezcla(original) != sorted(original):
+        print("FALLA", original)
+
+print("pruebas terminadas")
+ +
+
+
    +
  1. Escribe ordenar_mezcla diciendo las tres palabras: partir, ordenar cada mitad, mezclar.
  2. +
  3. Corre las 500 pruebas. Listas cortas y con repetidos: ahí se esconden los errores.
  4. +
  5. Planta un error: cambia <= 1 por == 1. ¿Falla? Sí, con RecursionError en la prueba 4, la primera lista vacía: [] se parte en [] y [] para siempre.
  6. +
  7. Por eso n empieza en 0: una prueba sin la lista vacía no lo habría visto.
  8. +
+
+
+
+ +
+
El esquema tiene nombre
+

Dividir, vencer, combinar

+ + + + + + +
Búsqueda binaria (conferencia 8)Ordenación por mezcla
Dividirmirar el del medio: casi gratispartir por la mitad: casi gratis
Venceruna mitad, la que puede tener el valorlas dos mitades, con la misma función
Combinarnada: la respuesta de la mitad es la respuestamezclar: n por nivel
Costolog₂ n niveles, una llamada cada uno: log₂ nlog₂ n niveles, n en cada uno: n log₂ n
+

Que un problema se pueda partir no basta: el costo depende de cuánto cuestan las tres partes. La mezcla parte gratis y trabaja al combinar. La que viene hace lo contrario.

+
+ + +
+
Parte 3
+

Trabajar al partir

+

La ordenación rápida reparte la lista alrededor de un pivote, y así combinar no cuesta nada.

+
+ +
+
Ordenación rápida
+

Menores, iguales, mayores, y pegar

+
+
+
def ordenar_rapida(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    pivote = lista[0]
+    menores, iguales, mayores = [], [], []
+    for x in lista:
+        if x < pivote:
+            menores.append(x)
+        elif x == pivote:
+            iguales.append(x)
+        else:
+            mayores.append(x)
+    return (ordenar_rapida(menores) + iguales
+            + ordenar_rapida(mayores))
+
    +
  • Todos los menores van antes que los iguales, que van antes que los mayores: pegar con + ya da la lista ordenada.
  • +
  • iguales nunca está vacía: tiene al pivote. Por eso las dos llamadas reciben listas más pequeñas.
  • +
+
+
+
+
pivoteel que se reparteya en su lugar
+
+
+
+ +
+
El árbol de la rápida
+

El árbol depende de dónde cae el pivote

+
+
+
    +
  • La mezcla parte siempre a la mitad. La rápida parte donde caiga el pivote: el 38 deja cinco a la izquierda y dos a la derecha.
  • +
  • El pivote no baja: se queda en iguales. No se dibujan las llamadas con la lista vacía.
  • +
  • A la derecha, cuántos elementos se reparten en cada nivel.
  • +
+

Mira el escenario ya ordenada. ¿Cuántos niveles?

+
+
+
+
+ +
+ En vivo · archivo rapida.py +

Una lista ordenada la rompe

+
+
+
print(ordenar_rapida([38, 27, 43, 3, 9, 82, 10, 5]))
+
+ordenada = list(range(2000))
+try:
+    ordenar_rapida(ordenada)
+except RecursionError as error:
+    print(type(error).__name__, error)
+ +

Con el primero como pivote y la lista ordenada, el pivote es siempre el menor: menores vacía, mayores con todos los demás. Cada nivel quita un elemento.

+
+
+
    +
  1. Escribe ordenar_rapida y pruébala con las mismas 500 listas que la mezcla.
  2. +
  3. Pregunta: con list(range(2000)), ¿cuántos niveles tiene el árbol? 2000, y el tope de la conferencia 9 es mil.
  4. +
  5. Corre. Con 990 todavía termina; con 1000 ya no.
  6. +
  7. El trabajo: n + (n − 1) + … + 2, casi n²/2. Otra vez cuadrática, con la lista que más se da en la práctica: datos que alguien ya ordenó.
  8. +
+
+
+
+ +
+
El arreglo
+

El pivote al azar

+
+
+
def ordenar_rapida_azar(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    pivote = random.choice(lista)
+    ...     # lo demás, igual
+
+
+print(ordenar_rapida_azar(ordenada) == ordenada)
+ +
    +
  • random.choice(lista) devuelve un elemento cualquiera. Ahora ninguna lista es mala siempre.
  • +
  • El trabajo esperado es n log n con cualquier entrada. La demostración, en Diseño y Análisis de Algoritmos.
  • +
+
+
+
+

La misma lista ordenada de 16, con los dos pivotes. Mira el contador de niveles.

+
+
+
+ + +
+
Parte 4
+

El reloj

+

Contra los métodos de la conferencia 8 primero. Después, el millón.

+
+ +
+
La carrera
+

Una comparación por paso

+
+

Las tres sobre la misma lista de 32, y cada una avanza una comparación por paso. En la rápida cuentan el < y, si no era menor, el ==, como en el código. ¿Quién gana? Espera al reloj.

+
+ +
+
Los segundos
+

La ventaja crece con cada duplicación

+
+
+
+

Las mismas listas al azar para los cuatro. La selección y la inserción multiplican por cuatro; la mezcla y la rápida se quedan pegadas al fondo.

+

Tiempos del libro. Con listas tan cortas, la mezcla y la rápida duran milésimas y el reloj tiembla. Pero mira la última fila: la rápida es la más rápida de las cuatro, aunque en la carrera comparaba más que la mezcla.

+
+
+
+ +
+ En vivo · archivo millon.py, con las dos funciones +

El millón, por fin

+
+
+
random.seed(8)
+millon = [random.randint(1, 1_000_000) for _ in range(1_000_000)]
+
+for nombre, metodo in [("mezcla", ordenar_mezcla),
+                       ("rápida", ordenar_rapida_azar),
+                       ("sorted", sorted)]:
+    inicio = time.perf_counter()
+    resultado = metodo(millon)
+    print(f"{nombre:>7}: {time.perf_counter() - inicio:5.2f} s  "
+          f"{'bien' if resultado == sorted(millon) else 'MAL'}")
+ +
+
+
    +
  1. Recuerda la cuenta del principio: la selección, casi diez horas.
  2. +
  3. Pide una predicción para la mezcla. Corre y espera con el aula.
  4. +
  5. Segundos, en Python, con listas y append. No cambió la máquina ni el lenguaje: cambió el orden de crecimiento.
  6. +
  7. Los tiempos de la izquierda son los del libro. Los de tu laptop serán otros; el orden, no.
  8. +
+
+
+
+ +
+
La sorpresa
+

Más comparaciones, menos segundos

+
+
+
+

El mismo millón del libro, contado aparte. En la rápida cuentan el < y el ==.

+
+
+
# la mezcla: una vuelta por elemento colocado
+while i < len(a) and j < len(b):
+    if a[i] <= b[j]:
+        resultado.append(a[i])
+        i += 1
+
+# la rápida: una vuelta por elemento repartido
+for x in lista:
+    if x < pivote:
+        menores.append(x)
+

Contar comparaciones da el orden de crecimiento. El tiempo es ese orden por una constante: lo que cuesta cada vuelta. La de la mezcla calcula dos len, lee por índice y suma; la de la rápida recibe x y agrega.

+

Con el mismo orden, n log n, la constante decide.

+
+
+
+ +
+
¿Y sorted?
+

sorted es una mezcla escrita en C

+
+
+
Escrita en C
+
No en Python. Eso le da una constante mucho menor: el mismo trabajo, cada paso más barato.
+
+
+
Timsort
+
Es una ordenación por mezcla con mejoras: aprovecha los pedazos que ya vienen ordenados en la entrada.
+
+
+
Inserción abajo
+
Para los pedazos pequeños usa la inserción de la conferencia 8, que ahí es más rápida que seguir con la recursión.
+
+
+

Si la rápida es más rápida, ¿por qué sorted es una mezcla? Porque la documentación de Python promete que es estable: los iguales conservan su orden, y eso la rápida no lo da.

+
+ +
+
En la práctica
+

Los lenguajes usan las dos

+ + + + + + + +
DóndeQué usaPor qué
sorted, list.sort (Python)Timsort, una mezclapromete estabilidad
Arrays.sort de objetos (Java)Timsort, una mezclalos objetos iguales se distinguen: hace falta estabilidad
Arrays.sort de números (Java)rápida con dos pivotesdos números iguales son indistinguibles: la estabilidad no importa
std::sort (C++)introsort: rápida, que cambia de método si la recursión se hace muy hondavelocidad, y un peor caso n log n sin depender del azar
std::stable_sort (C++)una mezclalo dice el nombre
+

La regla: mezcla cuando hace falta estabilidad o un peor caso garantizado; rápida cuando no, por velocidad y memoria.

+
+ +
+
Para quien quiera más · no está en el libro
+

La rápida de verdad no crea listas

+
+
+
def particion(lista):
+    pivote = lista[-1]
+    k = 0                   # lista[:k]: los menores
+    for j in range(len(lista) - 1):
+        if lista[j] < pivote:
+            lista[k], lista[j] = lista[j], lista[k]
+            k += 1
+    lista[k], lista[-1] = lista[-1], lista[k]
+    return k
+
    +
  • Nuestra rápida crea tres listas en cada llamada. Las de las bibliotecas intercambian dentro de la misma lista.
  • +
  • La mezcla necesita una lista auxiliar del tamaño de lo que mezcla. Esta rápida, ninguna.
  • +
+
+
+
+
pivotemenores, ya a la izquierdaintercambio
+

Con ini y fin en lugar de la lista entera, y dos llamadas recursivas, es la ordenación rápida en el mismo lugar. Queda para Diseño y Análisis de Algoritmos.

+
+
+
+ + +
+
Resumen
+

Lo que te llevas de hoy

+ +
+ +
+
Ejercicios · están completos en el libro
+

Para la clase práctica

+
+
    +
  • mezclar_tres(a, b, c), de dos maneras. ¿Cuál compara menos?
  • +
  • ordenar_mezcla partiendo en tres. ¿Cuántos niveles? Mídelo.
  • +
  • ordenar_mezcla_ciclo(lista) sin recursión: el árbol de abajo arriba.
  • +
  • La rápida con x <= pivote: ¿la lista más corta que da RecursionError?
  • +
+
    +
  • contar_rapida(lista) con listas ordenadas. ¿Otra lista mala?
  • +
  • Las palabras del Quijote, de más a menos frecuente, con ordenar_mezcla.
  • +
  • seleccionar(lista, k) con una sola llamada recursiva. ¿Cuánto trabaja?
  • +
  • La rápida con un millón ya ordenado: niveles, tiempo, y qué pasa en Python.
  • +
+
+
+ +
+
Para el profesor · guion de demos
+

Los momentos en la laptop

+
+

Todo corre en la carpeta de la conferencia, con import random y import time arriba. millon.py importa las funciones de mezcla.py y rapida.py, o las tiene copiadas. Pulsa el número de la diapositiva y Enter para saltar a ella. En las animaciones: A anima o pausa, S da un paso, X reinicia.

+
+ +
+ +
+
+ → Espacio RePág siguiente · ← anterior
+ R revela las salidas ocultas · V salta a la próxima demo en vivo
+ A anima o pausa · S un paso · X reinicia la animación
+ número + Enter va a esa diapositiva · Inicio Fin
+ F pantalla completa · ? esta ayuda +
+
+ + + + \ No newline at end of file