SQL Interview Prep · Leçon

Parcourir un organigramme

Parcourir une hiérarchie employé-responsable jusqu’à n’importe quel niveau

Parcourir un organigramme est une leçon SQL Interview Prep gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Interview Prep comprend 4 leçons au total.

La question de l'organigramme

« Étant donné une table employees contenant id, name et manager_id, listez toutes les personnes sous un responsable donné, à n'importe quelle profondeur. » C'est l'une des questions d'entretien les plus courantes sur les CTE récursifs.

La table est autoréférentielle : manager_id pointe vers l'id d'une autre ligne. Dans cette leçon, vous la parcourrez vers le bas (les subordonnés) et vers le haut (la chaîne hiérarchique).

La table d'exemple

Imaginez les données suivantes. Le CEO a un responsable NULL. Tous les autres rendent compte à quelqu'un situé plus haut dans la chaîne.

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

Le parcours est donc : Ada → Ben → Dan → Eve. Gardez cela à l'esprit pendant le parcours.

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

Parcourir vers le bas depuis un responsable

Pour lister tous les subordonnés d'un responsable choisi, l'ancre sélectionne ce responsable (ou ses subordonnés directs), et le membre récursif suit manager_id vers le bas.

Ici, nous partons de Ben (identifiant 2) et recueillons toutes les personnes qui dépendent de lui.

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;

Lire les résultats

La requête ci-dessus renvoie Ben à la profondeur 1, Dan à la profondeur 2 et Eve à la profondeur 3. L'ancre a initialisé Ben ; la première itération a trouvé Dan (dont le responsable est Ben) ; la deuxième a trouvé Eve (dont le responsable est Dan) ; la troisième n'a trouvé personne, et la récursion s'est donc arrêtée.

Si l'intervieweur demande « à combien de niveaux Eve se trouve-t-elle sous Ben ? », la colonne depth répond directement : 3 moins 1 égale 2 niveaux.

Remonter jusqu'au CEO

La question inverse est tout aussi courante : « Affichez la chaîne hiérarchique complète d'Eve jusqu'au CEO. » Inversez le sens de la jointure — le membre récursif suit désormais le manager_id de la ligne courante vers son parent.

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;

Vers le bas ou vers le haut : la jointure s'inverse

La seule différence structurelle entre le parcours vers le bas et le parcours vers le haut est la condition de jointure :

Vers le bas (trouver les subordonnés) : e.manager_id = cte.id — faites correspondre les employés dont le responsable est une ligne que nous avons déjà obtenue.
Vers le haut (trouver les responsables) : e.id = cte.manager_id — faites correspondre l'employé dont l'identifiant est le responsable de notre ligne courante.

Savoir expliquer clairement cette inversion impressionne les intervieweurs.

Construire un arbre indenté

Une réponse soignée présente les résultats sous forme d'arbre indenté, en utilisant la depth pour répéter les espaces. Cela montre que vous savez présenter des résultats hiérarchiques et pas seulement les calculer.

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;

Accumuler le chemin

Pour afficher le trajet complet du CEO à chaque personne, transmettez une chaîne path. Il s'agit de la même technique que dans la leçon précédente, appliquée à l'organigramme.

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;

Compter les subordonnés de chaque responsable

Une question de suivi fréquente : « Combien de personnes dépendent directement ou indirectement de chaque responsable ? » Utilisez le sous-arbre récursif de chaque responsable, puis agrégez les résultats. Une méthode courante consiste à exécuter la récursion une fois par racine et à appliquer GROUP BY au responsable de départ.

Ici, nous comptons tous les subordonnés indirects sous Ada (le CEO) en parcourant l'ensemble de l'arbre et en comptant les lignes sous la racine.

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;

Erreurs courantes

Attention aux pièges suivants que les intervieweurs peuvent vous tendre :

Mauvais sens de la jointure — utiliser e.manager_id = cte.id alors que vous vouliez remonter renvoie le mauvais ensemble.
Oublier le filtre de l'ancre — omettez WHERE id = X et vous initialisez chaque ligne, ce qui renvoie toute la forêt.
Erreur de profondeur d'une unité — décidez si la ligne de départ est au niveau 0 ou 1 et restez cohérent.

Pourquoi ne pas utiliser une simple auto-jointure ?

Une auto-jointure peut récupérer un nombre fixe de niveaux : une jointure pour les subordonnés directs, deux pour les subordonnés de second niveau, et ainsi de suite. Mais vous devez connaître la profondeur à l'avance et écrire une jointure par niveau.

Un CTE récursif gère une profondeur arbitraire et inconnue dans une seule requête. Lorsqu'un intervieweur dit « la hiérarchie peut comporter un nombre quelconque de niveaux », cela exclut les auto-jointures simples et indique qu'il faut utiliser la récursion.

Vérification rapide

Assurez-vous de savoir inverser le sens du parcours.

Récapitulatif

Le parcours d'un organigramme est la structure récursive appliquée à une table autoréférentielle :

Descente : amorcez avec un responsable, puis effectuez la jointure e.manager_id = cte.id.
Remontée : amorcez avec un employé, puis effectuez la jointure e.id = cte.manager_id.
Conservez depth pour l'indentation et path pour la chaîne complète.
La récursivité gère toute profondeur inconnue, contrairement à une jointure de la table avec elle-même.

Ensuite : utiliser la récursivité pour générer des suites de nombres et de dates.

Questions Fréquemment Posées

La leçon « Parcourir un organigramme » est-elle gratuite ?

Oui — le texte complet de « Parcourir un organigramme » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Interview Prep, passe à CoddyKit PRO. Le cours SQL Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Parcourir un organigramme » ?

Parcourir une hiérarchie employé-responsable jusqu’à n’importe quel niveau Tu pratiques SQL Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Interview Prep ?

Aucune expérience préalable n'est requise. SQL Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Parcourir un organigramme » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Interview Prep ?

Oui. Chaque leçon SQL Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Membres d’ancrage et membres récursifs
Parcourir un organigramme
Générer des séries de nombres et de dates
Éviter la récursivité infinie

← Retour à SQL Interview Prep