Un curso no termina cuando se acaban las lecciones, sino cuando sabes seguir aprendiendo sin él. En esta lección tienes una biblioteca seleccionada y comentada: documentación oficial, libros, plataformas de práctica, visualizadores y los temas que continúan de forma natural lo que hemos visto. No es una lista para leerla entera, sino un mapa: de cada recurso te digo qué aporta y cuándo usarlo, para que acudas al adecuado según el momento. Cierra la lección un apartado sobre cómo estudiar con todo esto, que importa más que el material en sí.

1. Documentación oficial de Python
2. Libros: del accesible al de referencia
3. Plataformas de práctica (y cómo empezar sin frustrarse)
4. Visualizadores
5. Temas siguientes naturales
6. Seguir practicando con TaskFlow
7. Cómo estudiar con estos recursos

La documentación de Python es de las mejores del sector y debería ser tu primera parada, no la última.

Consejo: guarda TimeComplexity en marcadores. Es la versión oficial y siempre actualizada de la tabla de costes que construimos en el módulo 1.

No los leas en paralelo; cada uno tiene su momento.

• Grokking Algorithms (Aditya Bhargava; en español, Algoritmos: guía ilustrada para programadores). El más accesible que existe: explica con dibujos búsqueda binaria, hash, BFS, Dijkstra, grafos... Ejemplos en Python. Cuándo: justo ahora, al terminar este curso — te servirá de repaso desde otro ángulo y te introducirá con suavidad la programación dinámica y los problemas NP, que aquí no hemos tocado. Se lee en un par de semanas.
• Problem Solving with Algorithms and Data Structures using Python (Miller y Ranum; gratuito online en runestone.academy). Cubre casi el mismo temario que este curso, con implementaciones completas en Python y ejercicios interactivos ejecutables en el navegador. Cuándo: como segunda pasada del temario; leer otra implementación de una TablaHash o un AVL distinta de la tuya consolida muchísimo. Es la referencia natural para "ver el curso contado por otra persona".
• Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein — "CLRS"). La referencia académica: demostraciones formales, análisis riguroso, pseudocódigo. Más de 1 300 páginas. Cuándo: NO para leerlo de principio a fin ahora. Úsalo como enciclopedia: cuando necesites entender a fondo un algoritmo concreto (por qué Dijkstra falla con pesos negativos, el análisis amortizado del array dinámico), su capítulo será la explicación definitiva. Comprarlo o consultarlo en biblioteca; intimida, pero cada capítulo es autocontenido.

Las estructuras se fijan resolviendo problemas. Pero el error número uno es entrar en una plataforma, abrir un problema "medium" al azar, atascarse y concluir que "esto no es lo mío". Plan concreto:

• LeetCode (leetcode.com). El estándar de facto para preparar entrevistas. Lo importante: los problemas están etiquetados por estructura (stack, queue, hash-table, heap-priority-queue, binary-search-tree, graph...) y por dificultad. Cómo empezar: filtra por una etiqueta que domines (p. ej. stack) + dificultad Easy, y resuelve 5-10 problemas de esa etiqueta antes de cambiar. Reconocerás viejos amigos: el "Valid Parentheses" es tu filtro_balanceado; "Min Stack" es tu PilaConMinimo; "Course Schedule" es tu hay_ciclo + orden topológico.
• HackerRank (hackerrank.com). Parecido, con rutas guiadas ("Data Structures" track) que van de fácil a difícil de forma más progresiva que LeetCode. Buen punto de entrada si LeetCode te resulta árido.
• Exercism (exercism.org). Gratuito, con mentores humanos que revisan tu código y un track de Python excelente. Menos orientado a algoritmos puros y más a escribir Python limpio. Ideal para pulir estilo mientras practicas.

Reglas para no frustrarse, válidas en cualquier plataforma:

1. Fácil primero, y sin vergüenza. Diez problemas fáciles resueltos enseñan más que uno difícil abandonado.
2. Tiempo límite de atasco: 30-45 minutos de intento serio; después, mira la solución, entiéndela, ciérrala y reescríbela tú de memoria. Mirar soluciones no es trampa; es trampa mirarlas sin reescribirlas.
3. Una etiqueta por semana. La práctica agrupada por estructura crea el reflejo problema→estructura que entrenamos en 08-01.
4. Vuelve a los problemas resueltos una o dos semanas después. Si no te sale a la segunda, no estaba aprendido.

Ver una estructura moverse vale más que releer su descripción:

• VisuAlgo (visualgo.net). Animaciones paso a paso de casi todo el curso: listas enlazadas, pilas, colas, tablas hash (¡con colisiones y rehashing!), ABB, AVL con sus rotaciones, montículos, BFS/DFS, Dijkstra, Prim, Kruskal... Cuándo: al repasar un algoritmo que "más o menos" recuerdas — ver las rotaciones AVL animadas aclara en dos minutos lo que cuesta media hora sobre papel. Tiene modo examen para autoevaluarte.
• Python Tutor (pythontutor.com). Ejecuta tu propio código Python paso a paso dibujando la memoria: referencias, objetos, la pila de llamadas creciendo y encogiéndose en cada llamada recursiva. Cuándo: para depurar tu comprensión, no solo tu código. Pega tu ListaEnlazada del módulo 2 y mira los nodos apuntándose; pega un recorrido recursivo y observa la pila de llamadas que estudiamos en el módulo 3 hacerse visible.

El curso te deja en la frontera de varios caminos. Ordenados por continuidad con lo que ya sabes:

No intentes abordarlos todos: elige uno (para un perfil junior, ordenación o programación dinámica son las apuestas más rentables) y dale un mes.

TaskFlow es tuyo: el mejor campo de prácticas es extenderlo. Ideas ordenadas de menor a mayor esfuerzo, cada una atada a lo que ejercita:

• Persistencia: guardar y cargar las tareas en JSON, midiendo con timeit cuánto cuesta reconstruir los índices al arrancar (módulos 1 y 5).
• Papelera con caducidad: tareas borradas recuperables durante N acciones — un deque(maxlen=N) de tuplas (tarea, acción en la que se borró) (módulos 3 y 4).
• Etiquetas jerárquicas: que trabajo/backend herede búsquedas de trabajo — árbol general + índice invertido colaborando (módulos 5 y 6).
• Recordatorios programados: un montículo por fecha de vencimiento que dispara avisos — tu BandejaUrgencias con el tiempo como prioridad (módulos 4 y 6).
• Modo multiusuario: grafo de colaboradores (quién ha trabajado con quién) con sugerir_colaboradores mejorado (módulo 7).
• Caché LRU real para las búsquedas frecuentes: implementa el diseño del ejercicio 3 de 08-01 y compáralo con functools.lru_cache (módulos 2 y 5).

La lección siguiente convierte tres de estas líneas en proyectos completos con requisitos y criterios de evaluación.

Adaptamos la sección habitual: aquí los errores son de uso de los recursos.

• Coleccionar en vez de estudiar. Guardar 40 enlaces produce la misma mejora que guardar cero. Regla: máximo un libro, una plataforma y un visualizador activos a la vez.
• El "tutorial infinito". Encadenar cursos y vídeos sin resolver problemas es la forma más cómoda de no avanzar. Proporción sana: por cada hora de lectura/vídeo, al menos una hora de teclado.
• Práctica espaciada, no atracones. Veinte minutos diarios durante un mes fijan más que un sábado de ocho horas. El olvido es el mecanismo: repasar justo cuando empiezas a olvidar (a los 2 días, a la semana, al mes) es lo que consolida.
• Implementar de memoria. El test definitivo de una estructura no es leerla: es cerrarlo todo y escribir tu TablaHash o tu BFS en un editor vacío. Hazlo con una estructura distinta cada semana.
• Explicar a otros. Escribe un pequeño artículo, contesta una duda en un foro o explícale los montículos a un compañero. Si no puedes explicarlo sin mirar, aún no era tuyo (y explicar es repasar).
• Medir la frustración como señal, no como veredicto. Atascarse es el estado normal del aprendizaje de algoritmos. La pregunta no es "¿me atasco?" sino "¿me atasco en cosas más difíciles que hace un mes?".

Elabora tu plan de estudio para las próximas 4 semanas usando solo recursos de esta lección: elige un libro, una plataforma con una etiqueta concreta de inicio y un tema "siguiente natural", y justifica cada elección en una frase según tu punto débil detectado en el test de 08-02.

Entra en la wiki TimeComplexity y responde con ella (no de memoria): (a) ¿qué coste tiene x in s para un set en el caso medio y en el peor caso? (b) ¿qué operación de deque es O(n) pese a la fama de "todo O(1)" de la estructura? (c) ¿coincide el peor caso de dict.get con lo que aprendiste en el módulo 5 sobre colisiones?

En VisuAlgo, sección de AVL, inserta la secuencia 1, 2, 3, 4, 5, 6, 7 y anota qué rotación dispara cada inserción. Después predice en papel qué pasará con la secuencia 7, 6, 5, 4, 3, 2, 1 y verifícalo en el visualizador.

Ejercicio 1. No hay una única respuesta; un plan tipo para un perfil que falló las preguntas de árboles del test: Problem Solving with A&DS (capítulos de árboles, porque da una segunda implementación completa), LeetCode etiqueta binary-search-tree en dificultad Easy (práctica agrupada del punto débil), y como tema siguiente "ordenación en detalle" (rentabiliza el Monticulo ya construido vía heapsort). Lo esencial es que cada elección se justifique por tu diagnóstico, no por popularidad.

Ejercicio 2. (a) O(1) medio, O(n) peor caso — el peor caso ocurre cuando todas las claves colisionan. (b) El acceso por índice en posiciones centrales, d[i], es O(n) (y también insert/remove en medio): el deque optimiza extremos, no interior. (c) Sí: el O(n) del peor caso de dict.get es exactamente el escenario de colisiones masivas del módulo 5 — todas las claves en el mismo cubo forman una cadena que hay que recorrer; el rehashing y una buena función hash lo hacen improbable, no imposible.

Ejercicio 3. Con 1..7 ascendente, cada desequilibrio es derecha-derecha y se corrige con rotaciones simples a la izquierda (disparan al insertar 3, 5 —reequilibrio local—, 6 y 7, según el estado del árbol). La predicción para 7..1: el caso espejo — desequilibrios izquierda-izquierda, rotaciones simples a la derecha en los puntos simétricos, y un árbol final con la misma forma equilibrada. Si tu anotación difiere en qué inserción exacta dispara cada rotación pero acertaste el tipo de rotación y la simetría, el concepto está aprendido.

Ya tienes la biblioteca: la documentación oficial como referencia diaria, Grokking y el libro de Runestone como siguientes lecturas, CLRS como enciclopedia, LeetCode/HackerRank/Exercism como gimnasio, VisuAlgo y Python Tutor como microscopio, y una lista corta de temas por los que crecer. Recuerda la regla que atraviesa toda la lección: pocos recursos, mucha práctica, espaciada y de memoria. Solo queda una cosa por hacer en este curso, y es la más importante: construir. En la última lección te esperan los tres proyectos finales.