SQL Interview Prep · Lección

Recorrer un organigrama

Recorra una jerarquía empleado-director a cualquier profundidad

Recorrer un organigrama es una lección gratuita de SQL Interview Prep en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de SQL Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de SQL Interview Prep incluye 4 lecciones en total.

La pregunta sobre el organigrama

"Dada una tabla employees con id, name y manager_id, enumere a todas las personas bajo un responsable determinado, a cualquier profundidad." Esta es una de las preguntas más habituales en entrevistas sobre CTE recursivas.

La tabla es autorrelacionada: manager_id apunta al id de otra fila. En esta lección recorrerá la estructura tanto hacia abajo (subordinados) como hacia arriba (cadena de mando).

La tabla de ejemplo

Imagine estos datos. El CEO tiene un responsable NULL. El resto de las personas reportan hacia arriba en la cadena.

1 Ada (responsable NULL)
2 Ben (responsable 1)
3 Cleo (responsable 1)
4 Dan (responsable 2)
5 Eve (responsable 4)

Por tanto, la profundidad es: Ada → Ben → Dan → Eve. Téngalo presente mientras recorremos la estructura.

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    manager_id INT REFERENCES employees(id)
);

Recorrer hacia abajo desde un responsable

Para enumerar a todos los subordinados de un responsable elegido, el ancla selecciona a ese responsable (o a sus subordinados directos), y el miembro recursivo sigue manager_id hacia abajo.

Aquí comenzamos por Ben (id 2) y recopilamos a todas las personas que están por debajo de él.

WITH RECURSIVE subtree AS (
    SELECT id, name, manager_id, 1 AS depth
    FROM employees WHERE id = 2
    UNION ALL
    SELECT e.id, e.name, e.manager_id, s.depth + 1
    FROM employees e
    JOIN subtree s ON e.manager_id = s.id
)
SELECT name, depth FROM subtree ORDER BY depth;

Interpretar el resultado

La consulta anterior devuelve a Ben en la profundidad 1, a Dan en la profundidad 2 y a Eve en la profundidad 3. El ancla inició a Ben; la primera iteración encontró a Dan (cuyo responsable es Ben); la segunda encontró a Eve (cuyo responsable es Dan); la tercera no encontró a nadie, por lo que la recursividad se detuvo.

Si el entrevistador pregunta "¿a cuántos niveles por debajo de Ben se encuentra Eve?", la columna depth responde directamente: 3 menos 1 equivale a 2 niveles.

Subir hasta el CEO

La pregunta inversa es igual de habitual: "Muestre la cadena de mando completa de Eve hasta el CEO." Invierta la dirección del JOIN — ahora el miembro recursivo sigue el manager_id de la fila actual hasta su superior.

WITH RECURSIVE chain AS (
    SELECT id, name, manager_id, 1 AS lvl
    FROM employees WHERE id = 5
    UNION ALL
    SELECT e.id, e.name, e.manager_id, c.lvl + 1
    FROM employees e
    JOIN chain c ON e.id = c.manager_id
)
SELECT name, lvl FROM chain ORDER BY lvl;

Hacia abajo frente a hacia arriba: el JOIN se invierte

La única diferencia estructural entre recorrer hacia abajo y recorrer hacia arriba es la condición del JOIN:

Hacia abajo (buscar subordinados): e.manager_id = cte.id — hace coincidir a los empleados cuyo responsable es una fila que ya tenemos.
Hacia arriba (buscar responsables): e.id = cte.manager_id — hace coincidir al empleado cuyo identificador es el responsable de nuestra fila actual.

Poder explicar claramente esta inversión causa una buena impresión en los entrevistadores.

Construir un árbol indentado

Una respuesta pulida presenta el resultado como un árbol indentado, utilizando depth para repetir espacios. Esto demuestra que sabe presentar resultados jerárquicos, no solo calcularlos.

WITH RECURSIVE org AS (
    SELECT id, name, 1 AS depth
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, o.depth + 1
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT REPEAT('  ', depth - 1) || name AS tree
FROM org
ORDER BY depth;

Acumular la ruta

Para mostrar la ruta completa desde el CEO hasta cada persona, conserve una cadena path. Esta es la misma técnica de la lección anterior, aplicada al organigrama.

WITH RECURSIVE org AS (
    SELECT id, name, CAST(name AS VARCHAR(500)) AS path
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, o.path || ' / ' || e.name
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT name, path FROM org ORDER BY path;

Contar los subordinados de cada responsable

Una pregunta de seguimiento frecuente: "¿Cuántas personas, directa o indirectamente, dependen de cada responsable?" Utilice el subárbol recursivo de cada responsable y, después, agregue los resultados. Un patrón habitual consiste en ejecutar la recursividad una vez por raíz y agrupar mediante GROUP BY el responsable inicial.

Aquí contamos todos los subordinados indirectos de Ada (la CEO) recorriendo todo el árbol y contando las filas que están por debajo de la raíz.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id, 0 AS depth
    FROM employees WHERE id = 1
    UNION ALL
    SELECT e.id, e.name, e.manager_id, o.depth + 1
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT COUNT(*) - 1 AS total_reports FROM org;

Errores habituales

Preste atención a estas trampas que plantean los entrevistadores:

Dirección incorrecta del JOIN — usar e.manager_id = cte.id cuando pretendía subir devuelve el conjunto equivocado.
Olvidar el filtro del ancla — si omite WHERE id = X, inicia la recursividad con todas las filas y devuelve todo el bosque.
Desfase de uno en la profundidad — decida si la semilla corresponde a la profundidad 0 o 1 y mantenga la coherencia.

¿Por qué no usar simplemente un self-join?

Un self-join puede obtener un número fijo de niveles: un JOIN para los subordinados directos, dos para los subordinados de segundo nivel, y así sucesivamente. Pero debe conocer de antemano la profundidad y escribir un JOIN por cada nivel.

Una CTE recursiva gestiona una profundidad arbitraria y desconocida en una sola consulta. Cuando un entrevistador dice "la jerarquía puede tener cualquier número de niveles", está descartando los self-joins simples y señalando que debe usar recursividad.

Comprobación rápida

Asegúrese de que sabe invertir la dirección del recorrido.

Repaso

El recorrido de un organigrama es la estructura recursiva aplicada a una tabla autorreferenciada:

Hacia abajo: inicialice un gerente y una la tabla con e.manager_id = cte.id.
Hacia arriba: inicialice un empleado y una la tabla con e.id = cte.manager_id.
Conserve depth para la sangría y path para la cadena completa.
La recursión admite cualquier profundidad desconocida, algo que una autocombinación no puede hacer.

A continuación: usar la recursión para generar series de números y fechas.

Preguntas frecuentes

¿La lección «Recorrer un organigrama» es gratis?

Sí — el texto completo de «Recorrer un organigrama» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de SQL Interview Prep, actualiza a CoddyKit PRO. El curso de SQL Interview Prep incluye 4 lecciones en total.

¿Qué aprenderé en «Recorrer un organigrama»?

Recorra una jerarquía empleado-director a cualquier profundidad Practicas SQL Interview Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar SQL Interview Prep?

No se requiere experiencia previa. SQL Interview Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Recorrer un organigrama»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de SQL Interview Prep?

Sí. Cada lección de SQL Interview Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a SQL Interview Prep