BFS and DFS Graph Traversal Visualizer

BFS(start):  queue = [start]; mark start as seen  while queue is not empty    v = queue.dequeue(); visit v    for each neighbour w of v      if w not seen: mark w; queue.enqueue(w) DFS(start):   // iterative, with a stack  stack = [start]  while stack is not empty    v = stack.pop()    if v is visited: continue    visit v    for each neighbour w of v (in reverse order)      if w not visited: stack.push(w)

// adj[v] = list of neighbours
std::vector<int> bfs(const std::vector<std::vector<int>>& adj, int start) {
    std::vector<int> order; std::vector<bool> seen(adj.size());
    std::queue<int> q; q.push(start); seen[start] = true;
    while (!q.empty()) {
        int v = q.front(); q.pop(); order.push_back(v);
        for (int w : adj[v]) if (!seen[w]) { seen[w] = true; q.push(w); }
    }
    return order;
}
std::vector<int> dfs(const std::vector<std::vector<int>>& adj, int start) {
    std::vector<int> order; std::vector<bool> visited(adj.size());
    std::stack<int> st; st.push(start);
    while (!st.empty()) {
        int v = st.top(); st.pop();
        if (visited[v]) continue;
        visited[v] = true; order.push_back(v);
        for (auto it = adj[v].rbegin(); it != adj[v].rend(); ++it)
            if (!visited[*it]) st.push(*it);
    }
    return order;
}

static List<Integer> bfs(List<List<Integer>> adj, int start) {
    List<Integer> order = new ArrayList<>();
    boolean[] seen = new boolean[adj.size()];
    Deque<Integer> q = new ArrayDeque<>();
    q.add(start); seen[start] = true;
    while (!q.isEmpty()) {
        int v = q.poll(); order.add(v);
        for (int w : adj.get(v)) if (!seen[w]) { seen[w] = true; q.add(w); }
    }
    return order;
}
static void dfs(List<List<Integer>> adj, int v, boolean[] visited, List<Integer> order) {
    visited[v] = true; order.add(v);            // recursive DFS
    for (int w : adj.get(v)) if (!visited[w]) dfs(adj, w, visited, order);
}

from collections import deque

def bfs(adj, start):
    order, seen, q = [], {start}, deque([start])
    while q:
        v = q.popleft()
        order.append(v)
        for w in adj[v]:
            if w not in seen:
                seen.add(w)
                q.append(w)
    return order

def dfs(adj, start):
    order, visited, stack = [], set(), [start]
    while stack:
        v = stack.pop()
        if v in visited:
            continue
        visited.add(v)
        order.append(v)
        for w in reversed(adj[v]):
            if w not in visited:
                stack.append(w)
    return order

adj = {'A': ['B', 'C'], 'B': ['A', 'D'], 'C': ['A'], 'D': ['B']}
print(bfs(adj, 'A'), dfs(adj, 'A'))

function bfs(adj, start) {
  const order = [], seen = new Set([start]), q = [start];
  for (let i = 0; i < q.length; i++) {      // q[i] is the front
    const v = q[i];
    order.push(v);
    for (const w of adj[v]) if (!seen.has(w)) { seen.add(w); q.push(w); }
  }
  return order;
}
function dfs(adj, start) {
  const order = [], visited = new Set(), stack = [start];
  while (stack.length) {
    const v = stack.pop();
    if (visited.has(v)) continue;
    visited.add(v);
    order.push(v);
    for (const w of [...adj[v]].reverse()) if (!visited.has(w)) stack.push(w);
  }
  return order;
}