Operation costs across five languages

Python 3.14 · main.py

from collections import deque

# The lesson's graph: 8 nodes, each edge listed once.
EDGES = [(0, 1), (0, 2), (0, 3), (1, 4), (2, 4), (2, 5), (3, 6), (4, 7), (5, 7), (6, 7)]
N = 8

neighbours: list[list[int]] = [[] for _ in range(N)]
for a, b in EDGES:
    neighbours[a].append(b)
    neighbours[b].append(a)

distance = [-1] * N
distance[0] = 0
queue = deque([0])
order: list[int] = []
most_waiting = moved = 0
while queue:
    node = queue.popleft()  # nothing behind the front moves
    moved += len(queue)  # what removing the front of an array would shift
    order.append(node)
    for nxt in neighbours[node]:
        if distance[nxt] == -1:
            distance[nxt] = distance[node] + 1
            queue.append(nxt)
    most_waiting = max(most_waiting, len(queue))

print("visit order:", *order)
print("distances:", *distance)
print("most nodes waiting at once:", most_waiting)
print("items a front removal from an array would move:", moved)

In Python: deque.popleft() takes the front in O(1); the collections documentation gives a list O(n) memory movement for pop(0), every item behind the front shifting one place.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

// The lesson's graph: 8 nodes, each edge listed once.
const EDGES = [
  [0, 1],
  [0, 2],
  [0, 3],
  [1, 4],
  [2, 4],
  [2, 5],
  [3, 6],
  [4, 7],
  [5, 7],
  [6, 7],
];
const N = 8;

const neighbours = Array.from({ length: N }, () => []);
for (const [a, b] of EDGES) {
  neighbours[a].push(b);
  neighbours[b].push(a);
}

const distance = new Array(N).fill(-1);
distance[0] = 0;
const queue = [0];
let head = 0;
const order = [];
let mostWaiting = 0;
let moved = 0;
while (head < queue.length) {
  const node = queue[head++]; // nothing behind the front moves
  moved += queue.length - head; // what removing the front of an array would shift
  order.push(node);
  for (const next of neighbours[node]) {
    if (distance[next] === -1) {
      distance[next] = distance[node] + 1;
      queue.push(next);
    }
  }
  mostWaiting = Math.max(mostWaiting, queue.length - head);
}

console.log(`visit order: ${order.join(" ")}`);
console.log(`distances: ${distance.join(" ")}`);
console.log(`most nodes waiting at once: ${mostWaiting}`);
console.log(`items a front removal from an array would move: ${moved}`);

In JavaScript: JavaScript has no queue type, and shift() moves every later element down one index, so the queue is an array read through a head index that only moves forward.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
  // The lesson's graph: 8 nodes, each edge listed once.
  static final int[][] EDGES = {
    {0, 1}, {0, 2}, {0, 3}, {1, 4}, {2, 4}, {2, 5}, {3, 6}, {4, 7}, {5, 7}, {6, 7}
  };
  static final int N = 8;

  static String joined(List<Integer> values) {
    StringBuilder line = new StringBuilder();
    for (int value : values) {
      line.append(line.length() == 0 ? "" : " ").append(value);
    }
    return line.toString();
  }

  public static void main(String[] args) {
    List<List<Integer>> neighbours = new ArrayList<>();
    for (int i = 0; i < N; i++) {
      neighbours.add(new ArrayList<>());
    }
    for (int[] edge : EDGES) {
      neighbours.get(edge[0]).add(edge[1]);
      neighbours.get(edge[1]).add(edge[0]);
    }

    int[] distance = new int[N];
    Arrays.fill(distance, -1);
    distance[0] = 0;
    ArrayDeque<Integer> queue = new ArrayDeque<>();
    queue.add(0);
    List<Integer> order = new ArrayList<>();
    int mostWaiting = 0;
    int moved = 0;
    while (!queue.isEmpty()) {
      int node = queue.poll(); // nothing behind the front moves
      moved += queue.size(); // what removing the front of an array would shift
      order.add(node);
      for (int next : neighbours.get(node)) {
        if (distance[next] == -1) {
          distance[next] = distance[node] + 1;
          queue.add(next);
        }
      }
      mostWaiting = Math.max(mostWaiting, queue.size());
    }

    List<Integer> distances = new ArrayList<>();
    for (int d : distance) {
      distances.add(d);
    }
    System.out.println("visit order: " + joined(order));
    System.out.println("distances: " + joined(distances));
    System.out.println("most nodes waiting at once: " + mostWaiting);
    System.out.println("items a front removal from an array would move: " + moved);
  }
}

In Java: ArrayDeque, whose documentation says most operations run in amortized constant time, takes the front with poll(); ArrayList.remove(0) would shift every later element.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <algorithm>
#include <array>
#include <print>
#include <queue>
#include <string>
#include <utility>
#include <vector>

// The lesson's graph: 8 nodes, each edge listed once.
constexpr std::array<std::pair<int, int>, 10> edges = {{{0, 1},
                                                        {0, 2},
                                                        {0, 3},
                                                        {1, 4},
                                                        {2, 4},
                                                        {2, 5},
                                                        {3, 6},
                                                        {4, 7},
                                                        {5, 7},
                                                        {6, 7}}};
constexpr int n = 8;

std::string joined(const std::vector<int> &values) {
  std::string line;
  for (const int value : values) {
    line += (line.empty() ? "" : " ") + std::to_string(value);
  }
  return line;
}

int main() {
  std::vector<std::vector<int>> neighbours(n);
  for (const auto &[a, b] : edges) {
    neighbours[a].push_back(b);
    neighbours[b].push_back(a);
  }

  std::vector<int> distance(n, -1);
  distance[0] = 0;
  std::queue<int> queue;
  queue.push(0);
  std::vector<int> order;
  std::size_t most_waiting = 0;
  std::size_t moved = 0;
  while (!queue.empty()) {
    const int node = queue.front();
    queue.pop();           // nothing behind the front moves
    moved += queue.size(); // what removing the front of an array would shift
    order.push_back(node);
    for (const int next : neighbours[node]) {
      if (distance[next] == -1) {
        distance[next] = distance[node] + 1;
        queue.push(next);
      }
    }
    most_waiting = std::max(most_waiting, queue.size());
  }

  std::println("visit order: {}", joined(order));
  std::println("distances: {}", joined(distance));
  std::println("most nodes waiting at once: {}", most_waiting);
  std::println("items a front removal from an array would move: {}", moved);
}

In C++: std::queue sits on std::deque by default, which inserts and removes at both ends in constant time; erasing the front of a std::vector moves every later element.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// The lesson's graph: 8 nodes, each edge listed once.
(int A, int B)[] edges =
[
    (0, 1), (0, 2), (0, 3), (1, 4), (2, 4),
    (2, 5), (3, 6), (4, 7), (5, 7), (6, 7),
];
const int N = 8;

var neighbours = new List<int>[N];
for (int i = 0; i < N; i++)
{
    neighbours[i] = [];
}
foreach (var (a, b) in edges)
{
    neighbours[a].Add(b);
    neighbours[b].Add(a);
}

var distance = new int[N];
Array.Fill(distance, -1);
distance[0] = 0;
var queue = new Queue<int>();
queue.Enqueue(0);
var order = new List<int>();
int mostWaiting = 0;
int moved = 0;
while (queue.Count > 0)
{
    int node = queue.Dequeue(); // nothing behind the front moves
    moved += queue.Count; // what removing the front of an array would shift
    order.Add(node);
    foreach (int next in neighbours[node])
    {
        if (distance[next] == -1)
        {
            distance[next] = distance[node] + 1;
            queue.Enqueue(next);
        }
    }
    mostWaiting = Math.Max(mostWaiting, queue.Count);
}

Console.WriteLine($"visit order: {string.Join(" ", order)}");
Console.WriteLine($"distances: {string.Join(" ", distance)}");
Console.WriteLine($"most nodes waiting at once: {mostWaiting}");
Console.WriteLine($"items a front removal from an array would move: {moved}");

In C#: Queue<T>.Dequeue is an O(1) operation by its documentation, while List<T>.RemoveAt(0) is O(n), its n being Count minus the index.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stddef.h>
#include <stdio.h>

enum { N = 8, EDGE_COUNT = 10 };

// The lesson's graph: 8 nodes, each edge listed once.
static const int edges[EDGE_COUNT][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 4},
                                         {2, 4}, {2, 5}, {3, 6}, {4, 7},
                                         {5, 7}, {6, 7}};

static void print_line(const char *label, const int *values, size_t count) {
  printf("%s:", label);
  for (size_t i = 0; i < count; i++) {
    printf(" %d", values[i]);
  }
  printf("\n");
}

int main(void) {
  int neighbours[N][N];
  size_t degree[N] = {0};
  for (size_t i = 0; i < EDGE_COUNT; i++) {
    const int a = edges[i][0];
    const int b = edges[i][1];
    neighbours[a][degree[a]++] = b;
    neighbours[b][degree[b]++] = a;
  }

  int distance[N];
  for (size_t i = 0; i < N; i++) {
    distance[i] = -1;
  }
  distance[0] = 0;
  int queue[N];
  size_t head = 0;
  size_t tail = 0;
  queue[tail++] = 0;
  int order[N];
  size_t visited = 0;
  size_t most_waiting = 0;
  size_t moved = 0;
  while (head < tail) {
    const int node = queue[head++]; // nothing behind the front moves
    moved += tail - head; // what removing the front of an array would shift
    order[visited++] = node;
    for (size_t k = 0; k < degree[node]; k++) {
      const int next = neighbours[node][k];
      if (distance[next] == -1) {
        distance[next] = distance[node] + 1;
        queue[tail++] = next;
      }
    }
    if (tail - head > most_waiting) {
      most_waiting = tail - head;
    }
  }

  print_line("visit order", order, visited);
  print_line("distances", distance, N);
  printf("most nodes waiting at once: %zu\n", most_waiting);
  printf("items a front removal from an array would move: %zu\n", moved);
  return 0;
}

In C: C's standard library has no queue, so the queue is an array with a head and a tail index. Each node joins at most once, so N slots never fill.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

// The lesson's graph: 8 nodes, each edge listed once.
const EDGES = [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [2, 5], [3, 6], [4, 7], [5, 7], [6, 7]];
const N = 8;

$neighbours = array_fill(0, N, []);
foreach (EDGES as [$a, $b]) {
    $neighbours[$a][] = $b;
    $neighbours[$b][] = $a;
}

$distance = array_fill(0, N, -1);
$distance[0] = 0;
$queue = new SplQueue();
$queue->enqueue(0);
$order = [];
$mostWaiting = 0;
$moved = 0;
while (!$queue->isEmpty()) {
    $node = $queue->dequeue(); // nothing behind the front moves
    $moved += count($queue); // what removing the front of an array would shift
    $order[] = $node;
    foreach ($neighbours[$node] as $next) {
        if ($distance[$next] === -1) {
            $distance[$next] = $distance[$node] + 1;
            $queue->enqueue($next);
        }
    }
    $mostWaiting = max($mostWaiting, count($queue));
}

echo 'visit order: ', implode(' ', $order), "\n";
echo 'distances: ', implode(' ', $distance), "\n";
echo "most nodes waiting at once: {$mostWaiting}\n";
echo "items a front removal from an array would move: {$moved}\n";

In PHP: SplQueue is a doubly linked list, so dequeue() unlinks the front node, while array_shift() renumbers every remaining key from zero.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::collections::VecDeque;

// The lesson's graph: 8 nodes, each edge listed once.
const EDGES: [(usize, usize); 10] = [
    (0, 1),
    (0, 2),
    (0, 3),
    (1, 4),
    (2, 4),
    (2, 5),
    (3, 6),
    (4, 7),
    (5, 7),
    (6, 7),
];
const N: usize = 8;

fn joined<T: ToString>(values: impl IntoIterator<Item = T>) -> String {
    let parts: Vec<String> = values.into_iter().map(|v| v.to_string()).collect();
    parts.join(" ")
}

fn main() {
    let mut neighbours = vec![Vec::new(); N];
    for (a, b) in EDGES {
        neighbours[a].push(b);
        neighbours[b].push(a);
    }

    let mut distance: Vec<Option<u32>> = vec![None; N];
    distance[0] = Some(0);
    let mut queue = VecDeque::from([0]);
    let mut order = Vec::new();
    let (mut most_waiting, mut moved) = (0, 0);
    // pop_front: nothing behind the front moves
    while let Some(node) = queue.pop_front() {
        moved += queue.len(); // what removing the front of an array would shift
        order.push(node);
        let next_distance = distance[node].map(|d| d + 1);
        for &next in &neighbours[node] {
            if distance[next].is_none() {
                distance[next] = next_distance;
                queue.push_back(next);
            }
        }
        most_waiting = most_waiting.max(queue.len());
    }

    println!("visit order: {}", joined(&order));
    let distances = distance.iter().map(|d| d.map_or(-1, i64::from));
    println!("distances: {}", joined(distances));
    println!("most nodes waiting at once: {most_waiting}");
    println!("items a front removal from an array would move: {moved}");
}

In Rust: VecDeque is a ring buffer, and the std::collections table gives its remove(i) O(min(i, n - i)), so the front costs O(1), against O(n - i) for a Vec.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

// The lesson's graph: 8 nodes, each edge listed once.
const EDGES: [number, number][] = [
  [0, 1],
  [0, 2],
  [0, 3],
  [1, 4],
  [2, 4],
  [2, 5],
  [3, 6],
  [4, 7],
  [5, 7],
  [6, 7],
];
const N = 8;

const neighbours: number[][] = Array.from({ length: N }, () => []);
for (const [a, b] of EDGES) {
  neighbours[a].push(b);
  neighbours[b].push(a);
}

const distance: number[] = new Array<number>(N).fill(-1);
distance[0] = 0;
const queue: number[] = [0];
let head = 0;
const order: number[] = [];
let mostWaiting = 0;
let moved = 0;
while (head < queue.length) {
  const node = queue[head++]; // nothing behind the front moves
  moved += queue.length - head; // what removing the front of an array would shift
  order.push(node);
  for (const next of neighbours[node]) {
    if (distance[next] === -1) {
      distance[next] = distance[node] + 1;
      queue.push(next);
    }
  }
  mostWaiting = Math.max(mostWaiting, queue.length - head);
}

console.log(`visit order: ${order.join(" ")}`);
console.log(`distances: ${distance.join(" ")}`);
console.log(`most nodes waiting at once: ${mostWaiting}`);
console.log(`items a front removal from an array would move: ${moved}`);

In TypeScript: As in JavaScript, the queue is a number[] read through a head index, since shift() would move every later element.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strconv"
	"strings"
)

// edges is the lesson's graph: 8 nodes, each edge listed once.
var edges = [][2]int{{0, 1}, {0, 2}, {0, 3}, {1, 4}, {2, 4}, {2, 5}, {3, 6}, {4, 7}, {5, 7}, {6, 7}}

const n = 8

func joined(values []int) string {
	parts := make([]string, len(values))
	for i, v := range values {
		parts[i] = strconv.Itoa(v)
	}
	return strings.Join(parts, " ")
}

func main() {
	neighbours := make([][]int, n)
	for _, e := range edges {
		neighbours[e[0]] = append(neighbours[e[0]], e[1])
		neighbours[e[1]] = append(neighbours[e[1]], e[0])
	}

	distance := make([]int, n)
	for i := range distance {
		distance[i] = -1
	}
	distance[0] = 0
	queue := []int{0}
	var order []int
	mostWaiting, moved := 0, 0
	for len(queue) > 0 {
		node := queue[0]
		queue = queue[1:]   // nothing behind the front moves
		moved += len(queue) // what removing the front of an array would shift
		order = append(order, node)
		for _, next := range neighbours[node] {
			if distance[next] == -1 {
				distance[next] = distance[node] + 1
				queue = append(queue, next)
			}
		}
		mostWaiting = max(mostWaiting, len(queue))
	}

	fmt.Println("visit order:", joined(order))
	fmt.Println("distances:", joined(distance))
	fmt.Println("most nodes waiting at once:", mostWaiting)
	fmt.Println("items a front removal from an array would move:", moved)
}

In Go: queue = queue[1:] makes a new slice over the same array and moves nothing; the array stays in memory until no slice refers to it.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

// The lesson's graph: 8 nodes, each edge listed once.
let edges = [(0, 1), (0, 2), (0, 3), (1, 4), (2, 4), (2, 5), (3, 6), (4, 7), (5, 7), (6, 7)]
let n = 8

var neighbours = [[Int]](repeating: [], count: n)
for (a, b) in edges {
  neighbours[a].append(b)
  neighbours[b].append(a)
}

var distance = [Int](repeating: -1, count: n)
distance[0] = 0
var queue = [0]
var head = 0
var order: [Int] = []
var mostWaiting = 0
var moved = 0
while head < queue.count {
  let node = queue[head]
  head += 1  // nothing behind the front moves
  moved += queue.count - head  // what removing the front of an array would shift
  order.append(node)
  for next in neighbours[node] where distance[next] == -1 {
    distance[next] = distance[node] + 1
    queue.append(next)
  }
  mostWaiting = max(mostWaiting, queue.count - head)
}

print("visit order: \(order.map(String.init).joined(separator: " "))")
print("distances: \(distance.map(String.init).joined(separator: " "))")
print("most nodes waiting at once: \(mostWaiting)")
print("items a front removal from an array would move: \(moved)")

In Swift: Array.removeFirst() is O(n) by its documentation, so the queue is an array read through a head index.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# The lesson's graph: 8 nodes, each edge listed once.
EDGES = [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [2, 5], [3, 6], [4, 7], [5, 7], [6, 7]].freeze
N = 8

neighbours = Array.new(N) { [] }
EDGES.each do |first, second|
  neighbours[first] << second
  neighbours[second] << first
end

distance = Array.new(N, -1)
distance[0] = 0
queue = [0]
head = 0
order = []
most_waiting = moved = 0
while head < queue.size
  node = queue[head]
  head += 1 # nothing behind the front moves
  moved += queue.size - head # what removing the front of an array would shift
  order << node
  neighbours[node].each do |nxt|
    next unless distance[nxt] == -1

    distance[nxt] = distance[node] + 1
    queue << nxt
  end
  most_waiting = [most_waiting, queue.size - head].max
end

puts "visit order: #{order.join(' ')}"
puts "distances: #{distance.join(' ')}"
puts "most nodes waiting at once: #{most_waiting}"
puts "items a front removal from an array would move: #{moved}"

In Ruby: Ruby's documentation states no cost for Array#shift, so this version reads the array through a head index, whose cost is one step per item.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

// The lesson's graph: 8 nodes, each edge listed once.
val edges = listOf(0 to 1, 0 to 2, 0 to 3, 1 to 4, 2 to 4, 2 to 5, 3 to 6, 4 to 7, 5 to 7, 6 to 7)
const val N = 8

fun main() {
    val neighbours = List(N) { mutableListOf<Int>() }
    for ((a, b) in edges) {
        neighbours[a].add(b)
        neighbours[b].add(a)
    }

    val distance = IntArray(N) { -1 }
    distance[0] = 0
    val queue = ArrayDeque(listOf(0))
    val order = mutableListOf<Int>()
    var mostWaiting = 0
    var moved = 0
    while (queue.isNotEmpty()) {
        val node = queue.removeFirst() // nothing behind the front moves
        moved += queue.size // what removing the front of an array would shift
        order.add(node)
        for (next in neighbours[node]) {
            if (distance[next] == -1) {
                distance[next] = distance[node] + 1
                queue.addLast(next)
            }
        }
        mostWaiting = maxOf(mostWaiting, queue.size)
    }

    println("visit order: ${order.joinToString(" ")}")
    println("distances: ${distance.joinToString(" ")}")
    println("most nodes waiting at once: $mostWaiting")
    println("items a front removal from an array would move: $moved")
}

In Kotlin: kotlin.collections.ArrayDeque, the standard library's resizable-array deque, takes the front with removeFirst().

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

import 'dart:collection';
import 'dart:math';

// The lesson's graph: 8 nodes, each edge listed once.
const edges = [
  (0, 1),
  (0, 2),
  (0, 3),
  (1, 4),
  (2, 4),
  (2, 5),
  (3, 6),
  (4, 7),
  (5, 7),
  (6, 7),
];
const n = 8;

void main() {
  final neighbours = List.generate(n, (_) => <int>[]);
  for (final (a, b) in edges) {
    neighbours[a].add(b);
    neighbours[b].add(a);
  }

  final distance = List.filled(n, -1);
  distance[0] = 0;
  final queue = ListQueue<int>()..add(0);
  final order = <int>[];
  var mostWaiting = 0;
  var moved = 0;
  while (queue.isNotEmpty) {
    final node = queue.removeFirst(); // nothing behind the front moves
    moved += queue.length; // what removing the front of an array would shift
    order.add(node);
    for (final next in neighbours[node]) {
      if (distance[next] == -1) {
        distance[next] = distance[node] + 1;
        queue.add(next);
      }
    }
    mostWaiting = max(mostWaiting, queue.length);
  }

  print('visit order: ${order.join(' ')}');
  print('distances: ${distance.join(' ')}');
  print('most nodes waiting at once: $mostWaiting');
  print('items a front removal from an array would move: $moved');
}

In Dart: ListQueue keeps a cyclic buffer, which its documentation says makes removing the front constant time; List.removeAt(0) moves every later element down one place.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart