Algorithms: Graph Algorithms Tutorials and Code Examples - Page 14

Breadth First Search Shortest Path in C++

BFS explores an unweighted graph one distance layer at a time.

cpp

int bfs_distance(const std::vector<int>& graph, int n, int source, int target) {
    alg_require(graph.size() <= 1000000);
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((int)graph.size() == alg_mul(n, n)));
    alg_require(((n >= 1) && (source >= 0) && (source < n)));
    alg_require(((target >= 0) && (target < n)));
    std::vector<int> distance(alg_size(n), 0);
    std::vector<int> queue(alg_size(n), 0);
    int v = 0;
    int u = 0;
    int head = 0;
    int tail = 1;

Nov 15, 2026 C++

Algorithms: Graph Algorithms

Breadth First Search Shortest Path in C

BFS explores an unweighted graph one distance layer at a time.

c

int bfs_distance(const int *graph, size_t graph_length, int n, int source, int target) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    int *distance = NULL;
    int *queue = NULL;
    if (graph_length > 1000000 || (graph_length && !graph)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((int)graph_length == alg_mul(n, n, &alg_error)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 1) && (source >= 0) && (source < n)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }

Nov 15, 2026 C

Algorithms: Graph Algorithms

Breadth First Search Shortest Path in Python

BFS explores an unweighted graph one distance layer at a time.

python

def bfs_distance(graph: list[int], n: int, source: int, target: int) -> int:
    alg_require(isinstance(graph, (list, tuple)) and len(graph) <= 1000000)
    alg_require(type(n) is int and -2147483648 <= n <= 2147483647)
    alg_require(type(source) is int and -2147483648 <= source <= 2147483647)
    alg_require(type(target) is int and -2147483648 <= target <= 2147483647)
    alg_require(n >= 0 and n <= 1000000)
    alg_require(len(graph) == n * n)
    alg_require(n >= 1 and source >= 0 and (source < n))
    alg_require(target >= 0 and target < n)
    distance: list[int] = [0] * alg_size(n)
    queue: list[int] = [0] * alg_size(n)
    v: int = 0

Nov 15, 2026 python

Algorithms: Graph Algorithms

Breadth First Search Shortest Path in JavaScript

BFS explores an unweighted graph one distance layer at a time.

javascript

function bfs_distance(graph, n, source, target) {
    alg_require(graph instanceof Int32Array);
    alg_require(Number.isInteger(n) && n >= -2147483648 && n <= 2147483647);
    alg_require(Number.isInteger(source) && source >= -2147483648 && source <= 2147483647);
    alg_require(Number.isInteger(target) && target >= -2147483648 && target <= 2147483647);
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require((graph.length == alg_mul(n, n)));
    alg_require(((n >= 1) && (source >= 0) && (source < n)));
    alg_require(((target >= 0) && (target < n)));
    let distance = new Int32Array(alg_size(n));
    let queue = new Int32Array(alg_size(n));
    let v = 0;

Nov 15, 2026 javascript

Algorithms: Graph Algorithms

Breadth First Search Shortest Path in Java

BFS explores an unweighted graph one distance layer at a time.

java

    static int bfs_distance(int[] graph, int n, int source, int target) {
        java.util.Objects.requireNonNull(graph, "graph");
        alg_require(((n >= 0) && (n <= 1000000)));
        alg_require((graph.length == Math.multiplyExact(n, n)));
        alg_require(((n >= 1) && (source >= 0) && (source < n)));
        alg_require(((target >= 0) && (target < n)));
        int[] distance = new int[alg_size(n)];
        int[] queue = new int[alg_size(n)];
        int v = 0;
        int u = 0;
        int head = 0;
        int tail = 1;

Nov 15, 2026 Java