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 @@ + + +
+ + +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.
+ +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.
+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.
+sorted ordena ese millón en 0,37 s. No es un n² escrito en un lenguaje más rápido: es otro algoritmo.
La pieza que no es recursiva. Todo lo demás se apoya en ella.
+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.
+while pone un elemento en resultado. Hay como mucho len(a) + len(b) vueltas.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.
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, 2, 3, 4, 5, 8, 9, 10, 12]+
mezclar con el aula. Dos índices, uno por montón.while en el ejemplo? Siete: cuando b llega al 10, a ya se acabó.mezclar([], [3, 4])? Ninguna vuelta: el extend copia b entera.Si sabes mezclar, ordenar es partir a la mitad, ordenar cada mitad y mezclar.
+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)+
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.
+¿Cuánto suma cada nivel?
+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.
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")
+ [3, 5, 9, 10, 27, 38, 43, 82] +pruebas terminadas+
ordenar_mezcla diciendo las tres palabras: partir, ordenar cada mitad, mezclar.<= 1 por == 1. ¿Falla? Sí, con RecursionError en la prueba 4, la primera lista vacía: [] se parte en [] y [] para siempre.n empieza en 0: una prueba sin la lista vacía no lo habría visto.| Búsqueda binaria (conferencia 8) | Ordenación por mezcla | |
|---|---|---|
| Dividir | mirar el del medio: casi gratis | partir por la mitad: casi gratis |
| Vencer | una mitad, la que puede tener el valor | las dos mitades, con la misma función |
| Combinar | nada: la respuesta de la mitad es la respuesta | mezclar: n por nivel |
| Costo | log₂ n niveles, una llamada cada uno: log₂ n | log₂ 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.
+La ordenación rápida reparte la lista alrededor de un pivote, y así combinar no cuesta nada.
+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))+
+ ya da la lista ordenada.iguales nunca está vacía: tiene al pivote. Por eso las dos llamadas reciben listas más pequeñas.iguales. No se dibujan las llamadas con la lista vacía.Mira el escenario ya ordenada. ¿Cuántos niveles?
+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)+
[3, 5, 9, 10, 27, 38, 43, 82] +RecursionError maximum recursion depth exceeded+
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.
ordenar_rapida y pruébala con las mismas 500 listas que la mezcla.list(range(2000)), ¿cuántos niveles tiene el árbol? 2000, y el tope de la conferencia 9 es mil.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)+
True+
random.choice(lista) devuelve un elemento cualquiera. Ahora ninguna lista es mala siempre.La misma lista ordenada de 16, con los dos pivotes. Mira el contador de niveles.
+Contra los métodos de la conferencia 8 primero. Después, el millón.
+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.
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.
+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'}")
+ mezcla: 4.14 s bien + rápida: 2.88 s bien + sorted: 0.37 s bien+
append. No cambió la máquina ni el lenguaje: cambió el orden de crecimiento.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.
+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.
| Dónde | Qué usa | Por qué |
|---|---|---|
sorted, list.sort (Python) | Timsort, una mezcla | promete estabilidad |
Arrays.sort de objetos (Java) | Timsort, una mezcla | los objetos iguales se distinguen: hace falta estabilidad |
Arrays.sort de números (Java) | rápida con dos pivotes | dos 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 honda | velocidad, y un peor caso n log n sin depender del azar |
std::stable_sort (C++) | una mezcla | lo dice el nombre |
La regla: mezcla cuando hace falta estabilidad o un peor caso garantizado; rápida cuando no, por velocidad y memoria.
+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+
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.
RecursionError. Con el pivote al azar, n log n esperado con cualquier entrada.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.x <= pivote: ¿la lista más corta que da RecursionError?contar_rapida(lista) con listas ordenadas. ¿Otra lista mala?ordenar_mezcla.seleccionar(lista, k) con una sola llamada recursiva. ¿Cuánto trabaja?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.