Ir al contenido
Ayotl
English

← Todos los cursos

Estructuras de datos desde cero

Un curso en lecciones cortas: cada una explica una idea con código que puedes cambiar y correr, y luego te pregunta. Lo que falles vuelve al final hasta que salga. No hace falta saber programar mucho; sí, tener ganas de probar. Tu avance se guarda en este navegador, sin cuenta.

0/32 lecciones0 xp0 días de racha

Unidad 1Antes de empezar

  1. 1
    ¿Qué es una estructura de datos?Datos, la forma de acomodarlos y lo que se puede hacer con ellos. Por qué este curso va en JavaScript.Empezar →
  2. Valores y referenciasPor qué cambiar un arreglo «copiado» cambia también el original. La base de las listas y los árboles.
  3. Cuánto cuesta: la O grandeContar pasos en vez de segundos: O(1), O(log n), O(n), O(n²). El idioma de todo lo que sigue.

Unidad 2Arreglos

  1. Arreglos e índicesCasillas en fila, numeradas desde 0: por qué leer cualquiera cuesta lo mismo, y las rejillas como arreglos de arreglos.
  2. Recorrer, meter y sacarPor qué meter al final es barato y al principio es caro, cómo buscar sin índice, y map, filter y reduce.
  3. Dos punteros y ventanasDos índices que caminan a la vez convierten muchos problemas de O(n²) en O(n). La técnica de media entrevista.

Unidad 3Pilas y colas

  1. Pilas: el último en entrar sale primeroUna pila de platos en código: push y pop, el botón de deshacer, la pila de llamadas y los paréntesis balanceados.
  2. Colas: el primero en llegar sale primeroLa fila de la tortillería en código, por qué shift sale caro y cómo hacer una cola O(1) con un índice.
  3. Cola circular y dequeUna cola de tamaño fijo que da la vuelta con el módulo, y una cola que deja entrar y salir por las dos puntas.

Unidad 4Listas enlazadas

  1. Nodos y punterosUna lista hecha de cajitas que se apuntan una a otra: recorrerla, meter al principio en O(1) y al final con una cola.
  2. Borrar, invertir y mezclarCambiar flechas en vez de mover datos: sacar un nodo, invertir una lista en su lugar y juntar dos listas ordenadas.
  3. Listas dobles y ciclosNodos que también apuntan hacia atrás, centinelas en las dos puntas y la tortuga y la liebre para detectar un ciclo.

Unidad 5Tablas hash

  1. La función hash y las cubetasConvertir una clave en el número de un cajón para encontrarla sin recorrer nada. Colisiones, factor de carga y por qué es O(1).
  2. Map y Set: las tablas hash de JavaScriptLas tablas hash que ya trae el lenguaje: contar, agrupar, quitar repetidos y encontrar parejas en una sola pasada.

Unidad 6Recursión

  1. Una función que se llama a sí mismaCaso base, la pila de llamadas y por qué el Fibonacci ingenuo explota. La herramienta para árboles y grafos.
  2. Divide y vencerásPartir el problema a la mitad: búsqueda binaria en O(log n) y merge sort en O(n log n).

Unidad 7Árboles

  1. Árboles binariosRaíz, hijos, hojas, altura y profundidad. Nodos que apuntan a dos nodos, y cómo armarlos en JavaScript.
  2. Recorridos en profundidadPreorden, inorden y postorden: el mismo árbol en tres órdenes. Altura, espejo y el ancestro común.
  3. Recorrido por nivelesVisitar el árbol piso por piso con una cola (BFS). Los niveles como arreglos y la vista desde la derecha.

Unidad 8Árboles binarios de búsqueda

  1. Buscar e insertar en un BSTMenores a la izquierda, mayores a la derecha: la regla que deja buscar descartando medio árbol en cada paso.
  2. Borrar, y por qué hay que balancearLos tres casos de borrar, el árbol que se vuelve lista con datos ordenados y cómo una rotación lo arregla.

Unidad 9Montículos

  1. Un árbol guardado en un arregloEl montículo mínimo: el más chico siempre arriba, sin punteros, y meter o sacar en O(log n).
  2. Colas de prioridadSale primero el más urgente, no el primero que llegó. Y los k más grandes de un millón sin ordenar el millón.

Unidad 10Grafos

  1. Puntos y líneas: qué es un grafoVértices y aristas, con flecha o sin ella, con peso o sin él. Guardarlos en lista de adyacencia o en matriz.
  2. Recorrer un grafo: BFS y DFSA lo ancho con una cola, a lo hondo con una pila. Distancias, componentes y las islas de un mapa.
  3. El camino más corto: DijkstraCuando las aristas pesan distinto, menos saltos no es menos kilómetros. El algoritmo de los mapas.
  4. Qué va primero: orden topológicoMaterias con prerrequisitos, tareas que dependen de otras: ponerlas en fila sin romper ninguna dependencia.

Unidad 11Estructuras avanzadas

  1. Trie: el árbol de los prefijosUn árbol con una letra por arista: buscar palabras y autocompletar sin importar cuántas haya guardadas.
  2. Union-Find: ¿están en el mismo grupo?Conjuntos disjuntos con un solo arreglo de padres: unir grupos y preguntar si dos cosas están juntas, casi en O(1).
  3. Sumas por rango: prefijos y FenwickSumar cualquier tramo de un arreglo en O(1) con sumas prefijas, y en O(log n) aunque los datos cambien, con un árbol de Fenwick.
  4. Caché LRUUna memoria de tamaño fijo que olvida lo que llevas más tiempo sin usar: con un Map de JavaScript, y con mapa más lista doble.
  5. Programación dinámica: no calcular dos vecesGuardar en un Map o en una tabla lo que ya calculaste: de exponencial a lineal en escaleras, monedas y subarreglos.