Contenido del curso
DFS
- 6

Cómo recorre nodos el algoritmo DFS
04:49 min - 7

Implementación de DFS recursivo para búsqueda en árboles
12:10 min - 8

Búsqueda en Profundidad (DFS) para Grafos: Enfoque Iterativo y Recursivo
01:27 min - 9

Inorder, Preorder y Postorder en árboles
Viendo ahora - 10

Suma de caminos raíz a hoja en árboles
02:04 min - 11

Suma de caminos raíz a hoja con DFS
07:31 min - 12

Playground: Sum Root to Leaf Numbers
- 13

Implementación de Algoritmo DFS en Árboles Binarios con Golang
15:03 min - 14

Número de islas con DFS en matrices
02:32 min - 15

Problema de islas resuelto con DFS
08:50 min - 16

Playground: Number of Islands
- 17

Número de islas con DFS recursivo en Python
10:18 min - 18

Ejercicios Prácticos de Búsqueda en Profundidad (DFS)
02:22 min - 19

Algoritmos de Búsqueda en Profundidad (DFS) en Problemas Comunes
06:19 min
BFS
- 20

Cómo BFS recorre grafos por niveles
02:05 min - 21

Implementación de BFS con colas en Python
08:42 min - 22

Mínimos movimientos del caballo en ajedrez
02:55 min - 23

Minimum Knight's Move con BFS
08:11 min - 24

Playground: Minimum Knights Moves
- 25

Resolución de Problemas de Caballos de Ajedrez con BFS en Python
17:49 min - 26

Propagación BFS en Rotting Oranges
03:50 min - 27

Resolución de Rotting Oranges usando BFS
08:43 min - 28

Playground: Rotting Oranges
- 29

Implementación de BFS para naranjas podridas
23:44 min - 30

Puente más corto entre islas con BFS
03:38 min - 31

Shortest Bridge: combina DFS y BFS
07:35 min - 32

Playground: Shortest Bridge Between Islands
- 33

Shortest Bridge con DFS y BFS en Python
14:57 min - 34

Búsqueda en anchura: Ejercicios prácticos y aplicaciones
03:41 min - 35

Ejercicios avanzados de búsqueda en anchura (BFS) en programación
08:47 min
Backtrack
- 36

Backtracking para encontrar soluciones válidas
04:20 min - 37

Combinaciones de letras en teclado telefónico
01:51 min - 38

Combinaciones de teclado con backtracking
09:19 min - 39

Generación de combinaciones de letras con teclados numéricos en C++
14:08 min - 40

Playground: Letter Combinations of a Phone Number
- 41

Generación de Direcciones IP Válidas a partir de Cadenas Numéricas
03:51 min - 42

Backtracking para generar IPs válidas
28:16 min - 43

Playground: Restore IP Addresses
- 44

Búsqueda de Palabras en Matrices: Solución y Complejidad
02:54 min - 45

Word Search con DFS y backtracking
08:30 min - 46

Playgrund: Word Search
- 47

Búsqueda de palabras en matrices con DFS
18:18 min - 48

Resolución del problema de las n reinas en ajedrez
01:08 min - 49

Ejercicios de Backtracking: Combinaciones y Permutaciones
01:05 min - 50

Combinaciones y Permutaciones con Backtracking
02:14 min
Próximos pasos
Inorder, Preorder y Postorder en árboles
Resumen
Cuando trabajas con estructuras de datos jerárquicas, entender cómo recorrer un árbol binario es la base para resolver problemas más complejos. Aquí vas a aprender los tres órdenes clásicos de recorrido (inorder, preorder, postorder) y cómo calcular la profundidad de un árbol, una habilidad clave en entrevistas técnicas y algoritmos recursivos.
¿Qué es un recorrido inorder en un árbol binario?
Imagina un nodo A con un hijo izquierdo I y un hijo derecho D. En un árbol binario, cada nodo tiene como máximo dos hijos, y el orden en que los visites cambia por completo el resultado del algoritmo [0:30].
El recorrido inorder sigue una secuencia muy específica: primero procesas el hijo izquierdo, luego el nodo actual y al final el hijo derecho. Es decir, el nodo actual queda "en medio" de sus hijos, y de ahí viene el nombre [1:00].
¿Cuándo conviene usar inorder? Cuando trabajas con árboles binarios de búsqueda, porque devuelve los nodos en orden ascendente de manera natural.
¿Cómo funcionan los recorridos preorder y postorder?
El recorrido preorder invierte la prioridad: primero procesas el nodo actual y después bajas a sus hijos. La lógica es directa: haces los cálculos en el nodo, luego visitas el hijo izquierdo y por último el derecho [1:30].
Si en lugar de un árbol binario tienes un árbol n-ario (con múltiples hijos por nodo), el preorder sigue siendo el mismo: te procesas a ti mismo y luego iteras sobre todos los hijos en un ciclo, sin importar cuántos sean [1:50].
El recorrido postorder hace lo contrario al preorder. Primero atiendes a los hijos (izquierdo, después derecho) y, al final, procesas el nodo actual. Es útil cuando necesitas información de los hijos antes de calcular algo en el padre, como al liberar memoria o evaluar expresiones aritméticas [2:20].
- Inorder: izquierdo, actual, derecho.
- Preorder: actual, izquierdo, derecho.
- Postorder: izquierdo, derecho, actual.
¿Qué es la profundidad de un árbol y cómo se calcula?
La profundidad de un árbol mide la longitud del camino entre nodos, contando cuántos nodos atraviesas para ir de uno a otro. Cuando hablas de la profundidad máxima o diámetro, te refieres al camino más largo desde la raíz hasta una hoja, entendiendo por hoja los nodos que ya no tienen hijos [2:50].
En un ejemplo concreto, un árbol puede tener una hoja a profundidad 2 y otra a profundidad 4. La profundidad mínima sería 2 y la máxima 4 [3:20].
¿Qué diferencia hay entre profundidad mínima y máxima? La mínima es el camino más corto de la raíz a una hoja; la máxima es el más largo. Ambas se calculan con la misma lógica recursiva, cambiando solo si comparas con
minomax.
¿Cómo escribir la recursión para calcular la profundidad?
La función recibe una raíz como entrada. El caso base ocurre cuando la raíz es nula: ahí detienes la recursión porque ya no hay nodos que recorrer [3:50].
Dentro de la función, llamas recursivamente a sí misma con raiz.izquierda y guardas el resultado, luego haces lo mismo con raiz.derecha. La recursión baja por el lado izquierdo hasta encontrar un nulo, regresa, y entonces baja por el derecho. Al subir de nuevo, sumas uno por cada nivel atravesado [4:30].
python def profundidad(raiz): if raiz is None: return 0 izquierda = profundidad(raiz.izquierda) derecha = profundidad(raiz.derecha) return max(izquierda, derecha) + 1
Para la profundidad mínima usas min en lugar de max. Si un lado no existe, le sumas uno al otro para evitar contar caminos incompletos [5:10].
¿Y si el árbol no es binario sino n-ario?
La lógica es prácticamente la misma, pero en vez de revisar solo izquierda y derecha, iteras sobre todos los hijos con un ciclo. Mantienes una variable de máxima profundidad y la actualizas cada vez que encuentras un valor mayor al guardado [5:50].
- Recorres el arreglo de hijos.
- Llamas recursivamente a
profundidad(hijo). - Comparas con la máxima registrada y actualizas si es necesario.
Esta misma estructura mental te servirá para resolver problemas como sum root to leaf numbers, donde combinas recorrido y acumulación de valores. ¿Qué orden de recorrido crees que se ajusta mejor a ese problema? Déjalo en los comentarios.