Recorrido en profundidad (DFS)

grafo = {}


def arista(a, b):
    grafo.setdefault(a, []).append(b)
    grafo.setdefault(b, []).append(a)


def dfs(u, vistos, orden):
    vistos.add(u)
    orden.append(u)
    for v in grafo[u]:
        if v not in vistos:
            dfs(v, vistos, orden)                   # baja ya; el resto de vecinos, a la vuelta


def dfs_con_pila(origen):
    vistos, orden, pila = set(), [], [origen]
    while pila:
        u = pila.pop()
        if u in vistos:
            continue                                # ya se visitó por otro camino
        vistos.add(u)
        orden.append(u)
        for v in reversed(grafo[u]):                # al revés: el primero queda en la cima
            if v not in vistos:
                pila.append(v)
    return orden


for a, b in [("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("C", "E"), ("D", "F"), ("E", "F"), ("F", "G")]:
    arista(a, b)
orden = []
dfs("A", set(), orden)
print("Recursivo: " + " ".join(orden))
print("Con pila:  " + " ".join(dfs_con_pila("A")))

const grafo = new Map();

function arista(a, b) {
    if (!grafo.has(a)) grafo.set(a, []);
    if (!grafo.has(b)) grafo.set(b, []);
    grafo.get(a).push(b);
    grafo.get(b).push(a);
}

function dfs(u, vistos, orden) {
    vistos.add(u);
    orden.push(u);
    for (const v of grafo.get(u))
        if (!vistos.has(v)) dfs(v, vistos, orden);   // baja ya; el resto de vecinos, a la vuelta
}

function dfsConPila(origen) {
    const vistos = new Set(), orden = [], pila = [origen];
    while (pila.length > 0) {
        const u = pila.pop();
        if (vistos.has(u)) continue;                 // ya se visitó por otro camino
        vistos.add(u);
        orden.push(u);
        const vecinos = grafo.get(u);
        for (let i = vecinos.length - 1; i >= 0; i--)   // al revés: el primero queda en la cima
            if (!vistos.has(vecinos[i])) pila.push(vecinos[i]);
    }
    return orden;
}

for (const [a, b] of [["A", "B"], ["A", "C"], ["B", "D"], ["C", "D"], ["C", "E"], ["D", "F"], ["E", "F"], ["F", "G"]]) arista(a, b);
const orden = [];
dfs("A", new Set(), orden);
console.log("Recursivo: " + orden.join(" "));
console.log("Con pila:  " + dfsConPila("A").join(" "));

using System;
using System.Collections.Generic;

class Program {
    static readonly Dictionary<string, List<string>> grafo = new();

    static void Arista(string a, string b) {
        if (!grafo.ContainsKey(a)) grafo[a] = new List<string>();
        if (!grafo.ContainsKey(b)) grafo[b] = new List<string>();
        grafo[a].Add(b);
        grafo[b].Add(a);
    }

    static void Dfs(string u, HashSet<string> vistos, List<string> orden) {
        vistos.Add(u);
        orden.Add(u);
        foreach (string v in grafo[u])
            if (!vistos.Contains(v)) Dfs(v, vistos, orden);   // baja ya; el resto de vecinos, a la vuelta
    }

    static List<string> DfsConPila(string origen) {
        var vistos = new HashSet<string>();
        var orden = new List<string>();
        var pila = new Stack<string>();
        pila.Push(origen);
        while (pila.Count > 0) {
            string u = pila.Pop();
            if (!vistos.Add(u)) continue;                     // ya se visitó por otro camino
            orden.Add(u);
            var vecinos = grafo[u];
            for (int i = vecinos.Count - 1; i >= 0; i--)      // al revés: el primero queda en la cima
                if (!vistos.Contains(vecinos[i])) pila.Push(vecinos[i]);
        }
        return orden;
    }

    static void Main() {
        foreach (var (a, b) in new[] { ("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("C", "E"), ("D", "F"), ("E", "F"), ("F", "G") }) Arista(a, b);
        var orden = new List<string>();
        Dfs("A", new HashSet<string>(), orden);
        Console.WriteLine("Recursivo: " + string.Join(" ", orden));
        Console.WriteLine("Con pila:  " + string.Join(" ", DfsConPila("A")));
    }
}

<?php
$grafo = [];
foreach ([["A", "B"], ["A", "C"], ["B", "D"], ["C", "D"], ["C", "E"], ["D", "F"], ["E", "F"], ["F", "G"]] as [$a, $b]) {
    $grafo[$a][] = $b;
    $grafo[$b][] = $a;
}

function dfs(array $g, string $u, array &$vistos, array &$orden): void {
    $vistos[$u] = true;
    $orden[] = $u;
    foreach ($g[$u] as $v)
        if (!isset($vistos[$v])) dfs($g, $v, $vistos, $orden);   // baja ya; el resto de vecinos, a la vuelta
}

function dfsConPila(array $g, string $origen): array {
    $vistos = [];
    $orden = [];
    $pila = [$origen];
    while ($pila) {
        $u = array_pop($pila);
        if (isset($vistos[$u])) continue;          // ya se visitó por otro camino
        $vistos[$u] = true;
        $orden[] = $u;
        foreach (array_reverse($g[$u]) as $v)      // al revés: el primero queda en la cima
            if (!isset($vistos[$v])) $pila[] = $v;
    }
    return $orden;
}

$vistos = [];
$orden = [];
dfs($grafo, "A", $vistos, $orden);
echo "Recursivo: " . implode(" ", $orden) . "\n";
echo "Con pila:  " . implode(" ", dfsConPila($grafo, "A")) . "\n";

def marcar(g, u, vistos, grupo):
    vistos.add(u)
    grupo.append(u)
    for v in g[u]:
        if v not in vistos:
            marcar(g, v, vistos, grupo)


def hay_ciclo(g, u, color):
    """color: 0 sin visitar, 1 en curso (en la pila de llamadas), 2 terminado."""
    color[u] = 1
    for v in g[u]:
        c = color.get(v, 0)
        if c == 1:
            return True                             # flecha hacia un nodo en curso: ciclo
        if c == 0 and hay_ciclo(g, v, color):
            return True
    color[u] = 2
    return False


def tiene_ciclo(g):
    color = {}
    for u in g:
        if color.get(u, 0) == 0 and hay_ciclo(g, u, color):
            return True
    return False


def grafo(nodos, aristas, dirigido):
    g = {n: [] for n in nodos}
    for a, b in aristas:
        g[a].append(b)
        if not dirigido:
            g[b].append(a)
    return g


red = grafo("ABCDEFGH", [("A", "B"), ("B", "C"), ("A", "C"), ("D", "E"), ("F", "G")], False)
vistos = set()
n = 0
for u in red:
    if u in vistos:
        continue
    grupo = []
    marcar(red, u, vistos, grupo)                   # un DFS por cada nodo que siga sin visitar
    n += 1
    print(f"Componente {n}: " + " ".join(grupo))

tareas = ["compilar", "enlazar", "probar", "desplegar"]
cadena = [("compilar", "enlazar"), ("enlazar", "probar"), ("probar", "desplegar")]
vuelta = cadena + [("desplegar", "enlazar")]
print("Tareas en cadena: " + ("hay un ciclo" if tiene_ciclo(grafo(tareas, cadena, True)) else "sin ciclos"))
print("Con desplegar → enlazar: " + ("hay un ciclo" if tiene_ciclo(grafo(tareas, vuelta, True)) else "sin ciclos"))

function marcar(g, u, vistos, grupo) {
    vistos.add(u);
    grupo.push(u);
    for (const v of g.get(u)) if (!vistos.has(v)) marcar(g, v, vistos, grupo);
}

/** color: 0 sin visitar, 1 en curso (en la pila de llamadas), 2 terminado. */
function hayCiclo(g, u, color) {
    color.set(u, 1);
    for (const v of g.get(u)) {
        const c = color.get(v) ?? 0;
        if (c === 1) return true;                    // flecha hacia un nodo en curso: ciclo
        if (c === 0 && hayCiclo(g, v, color)) return true;
    }
    color.set(u, 2);
    return false;
}

function tieneCiclo(g) {
    const color = new Map();
    for (const u of g.keys()) if ((color.get(u) ?? 0) === 0 && hayCiclo(g, u, color)) return true;
    return false;
}

function grafo(nodos, aristas, dirigido) {
    const g = new Map(nodos.map((n) => [n, []]));
    for (const [a, b] of aristas) {
        g.get(a).push(b);
        if (!dirigido) g.get(b).push(a);
    }
    return g;
}

const red = grafo([..."ABCDEFGH"], [["A", "B"], ["B", "C"], ["A", "C"], ["D", "E"], ["F", "G"]], false);
const vistos = new Set();
let n = 0;
for (const u of red.keys()) {
    if (vistos.has(u)) continue;
    const grupo = [];
    marcar(red, u, vistos, grupo);                   // un DFS por cada nodo que siga sin visitar
    console.log(`Componente ${++n}: ${grupo.join(" ")}`);
}

const tareas = ["compilar", "enlazar", "probar", "desplegar"];
const cadena = [["compilar", "enlazar"], ["enlazar", "probar"], ["probar", "desplegar"]];
const vuelta = [...cadena, ["desplegar", "enlazar"]];
console.log("Tareas en cadena: " + (tieneCiclo(grafo(tareas, cadena, true)) ? "hay un ciclo" : "sin ciclos"));
console.log("Con desplegar → enlazar: " + (tieneCiclo(grafo(tareas, vuelta, true)) ? "hay un ciclo" : "sin ciclos"));

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    static void Marcar(Dictionary<string, List<string>> g, string u, HashSet<string> vistos, List<string> grupo) {
        vistos.Add(u);
        grupo.Add(u);
        foreach (string v in g[u])
            if (!vistos.Contains(v)) Marcar(g, v, vistos, grupo);
    }

    // color: 0 sin visitar, 1 en curso (en la pila de llamadas), 2 terminado
    static bool HayCiclo(Dictionary<string, List<string>> g, string u, Dictionary<string, int> color) {
        color[u] = 1;
        foreach (string v in g[u]) {
            int c = color.GetValueOrDefault(v);
            if (c == 1) return true;                          // flecha hacia un nodo en curso: ciclo
            if (c == 0 && HayCiclo(g, v, color)) return true;
        }
        color[u] = 2;
        return false;
    }

    static bool TieneCiclo(Dictionary<string, List<string>> g) {
        var color = new Dictionary<string, int>();
        foreach (string u in g.Keys)
            if (color.GetValueOrDefault(u) == 0 && HayCiclo(g, u, color)) return true;
        return false;
    }

    static Dictionary<string, List<string>> Grafo(string[] nodos, (string, string)[] aristas, bool dirigido) {
        var g = new Dictionary<string, List<string>>();
        foreach (string n in nodos) g[n] = new List<string>();
        foreach (var (a, b) in aristas) {
            g[a].Add(b);
            if (!dirigido) g[b].Add(a);
        }
        return g;
    }

    static void Main() {
        var red = Grafo(new[] { "A", "B", "C", "D", "E", "F", "G", "H" },
            new[] { ("A", "B"), ("B", "C"), ("A", "C"), ("D", "E"), ("F", "G") }, false);
        var vistos = new HashSet<string>();
        int n = 0;
        foreach (string u in red.Keys) {
            if (vistos.Contains(u)) continue;
            var grupo = new List<string>();
            Marcar(red, u, vistos, grupo);                    // un DFS por cada nodo que siga sin visitar
            Console.WriteLine(
quot;Componente {++n}: {string.Join(" ", grupo)}");
        }

        string[] tareas = { "compilar", "enlazar", "probar", "desplegar" };
        var cadena = new[] { ("compilar", "enlazar"), ("enlazar", "probar"), ("probar", "desplegar") };
        var vuelta = cadena.Append(("desplegar", "enlazar")).ToArray();
        Console.WriteLine("Tareas en cadena: " + (TieneCiclo(Grafo(tareas, cadena, true)) ? "hay un ciclo" : "sin ciclos"));
        Console.WriteLine("Con desplegar → enlazar: " + (TieneCiclo(Grafo(tareas, vuelta, true)) ? "hay un ciclo" : "sin ciclos"));
    }
}

<?php
function marcar(array $g, string $u, array &$vistos, array &$grupo): void {
    $vistos[$u] = true;
    $grupo[] = $u;
    foreach ($g[$u] as $v)
        if (!isset($vistos[$v])) marcar($g, $v, $vistos, $grupo);
}

/** color: 0 sin visitar, 1 en curso (en la pila de llamadas), 2 terminado. */
function hayCiclo(array $g, string $u, array &$color): bool {
    $color[$u] = 1;
    foreach ($g[$u] as $v) {
        $c = $color[$v] ?? 0;
        if ($c === 1) return true;                     // flecha hacia un nodo en curso: ciclo
        if ($c === 0 && hayCiclo($g, $v, $color)) return true;
    }
    $color[$u] = 2;
    return false;
}

function tieneCiclo(array $g): bool {
    $color = [];
    foreach (array_keys($g) as $u)
        if (($color[$u] ?? 0) === 0 && hayCiclo($g, $u, $color)) return true;
    return false;
}

function grafo(array $nodos, array $aristas, bool $dirigido): array {
    $g = array_fill_keys($nodos, []);
    foreach ($aristas as [$a, $b]) {
        $g[$a][] = $b;
        if (!$dirigido) $g[$b][] = $a;
    }
    return $g;
}

$red = grafo(str_split("ABCDEFGH"), [["A", "B"], ["B", "C"], ["A", "C"], ["D", "E"], ["F", "G"]], false);
$vistos = [];
$n = 0;
foreach (array_keys($red) as $u) {
    if (isset($vistos[$u])) continue;
    $grupo = [];
    marcar($red, $u, $vistos, $grupo);              // un DFS por cada nodo que siga sin visitar
    $n++;
    echo "Componente $n: " . implode(" ", $grupo) . "\n";
}

$tareas = ["compilar", "enlazar", "probar", "desplegar"];
$cadena = [["compilar", "enlazar"], ["enlazar", "probar"], ["probar", "desplegar"]];
$vuelta = [...$cadena, ["desplegar", "enlazar"]];
echo "Tareas en cadena: " . (tieneCiclo(grafo($tareas, $cadena, true)) ? "hay un ciclo" : "sin ciclos") . "\n";
echo "Con desplegar → enlazar: " . (tieneCiclo(grafo($tareas, $vuelta, true)) ? "hay un ciclo" : "sin ciclos") . "\n";