Depth-First Search

// graph: adjacency list, e.g. { A: ["B", "C"], B: ["A", "D"], ... }
function dfs(graph, start) {
  const seen = new Set();
  const order = [];
  function visit(node) {
    seen.add(node);
    order.push(node);
    for (const next of graph[node]) {
      if (!seen.has(next)) visit(next);
    }
  }
  visit(start);
  return order;
}
// dfs(graph, "A") → ["A", "B", "D", "C", "E", "F", "G"]

# graph: adjacency list, e.g. {"A": ["B", "C"], "B": ["A", "D"], ...}
def dfs(graph, start):
    seen = set()
    order = []
 
    def visit(node):
        seen.add(node)
        order.append(node)
        for nxt in graph[node]:
            if nxt not in seen:
                visit(nxt)
 
    visit(start)
    return order
# dfs(graph, "A") → ['A', 'B', 'D', 'C', 'E', 'F', 'G']

function dfsIterative(graph, start) {
  const seen = new Set();
  const order = [];
  const stack = [start];
  while (stack.length > 0) {
    const node = stack.pop();
    if (seen.has(node)) continue; // pushed twice, already handled
    seen.add(node);
    order.push(node);
    const nbrs = graph[node];
    for (let i = nbrs.length - 1; i >= 0; i--) {
      if (!seen.has(nbrs[i])) stack.push(nbrs[i]);
    }
  }
  return order;
}

def dfs_iterative(graph, start):
    seen = set()
    order = []
    stack = [start]
    while stack:
        node = stack.pop()
        if node in seen:
            continue  # pushed twice, already handled
        seen.add(node)
        order.append(node)
        for nxt in reversed(graph[node]):
            if nxt not in seen:
                stack.append(nxt)
    return order

// grid: array of strings. "#" is land, "." is water.
function countIslands(grid) {
  const rows = grid.length, cols = grid[0].length;
  const seen = grid.map((row) => new Array(row.length).fill(false));
  function fill(r, c) {
    if (r < 0 || r >= rows || c < 0 || c >= cols) return; // off the map
    if (grid[r][c] !== "#" || seen[r][c]) return;         // water, or done
    seen[r][c] = true;
    fill(r - 1, c); fill(r + 1, c); fill(r, c - 1); fill(r, c + 1);
  }
  let islands = 0;
  for (let r = 0; r < rows; r++) {
    for (let c = 0; c < cols; c++) {
      if (grid[r][c] === "#" && !seen[r][c]) {
        islands++;  // a piece nobody has reached yet
        fill(r, c); // mark all of it
      }
    }
  }
  return islands;
}
 
countIslands(["##..#", "#...#", "..#..", "##..."]); // 4

# grid: list of strings. "#" is land, "." is water.
def count_islands(grid):
    rows, cols = len(grid), len(grid[0])
    seen = [[False] * cols for _ in range(rows)]
 
    def fill(r, c):
        if not (0 <= r < rows and 0 <= c < cols):
            return  # off the map
        if grid[r][c] != "#" or seen[r][c]:
            return  # water, or done
        seen[r][c] = True
        fill(r - 1, c); fill(r + 1, c); fill(r, c - 1); fill(r, c + 1)
 
    islands = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == "#" and not seen[r][c]:
                islands += 1  # a piece nobody has reached yet
                fill(r, c)    # mark all of it
    return islands
 
count_islands(["##..#", "#...#", "..#..", "##..."])  # 4