(A. S. Tanenbaum Számítógép-hálózatok c. könyve alapján.)

#define MAXNODES 1024                                /* maximum number of nodes */
#define INFINITY 1000000000                          /* larger than every maximum path */

int dist[MAXNODES][MAXNODES];                        /* dist[i][j] is the distance from i to j */

void shortestpath(int n, int s, int t, int path[]) {

    struct state {                                   /* the path being worked on */
        int predecessor;                             /* previous node */
        int length;                                  /* length from source to this node */
        enum {permanent, tentative} label;           /* label state: permanent, tentative */
    } state[MAXNODES];

    int i, k, min;
    struct state *p;

    for (p = &state[0]; p < &state[n]; p++) {        /* initialize state */
        p->predecessor = -1;    p->length = INFINITY;
        p->label = tentative;
    }

    state[t].length = 0;
    state[t].label = permanent;
    k = t;    /* k is the initial working node */

    do {                                             /* Is there a better path from k? */
        for (i = 0; i < n; i++)                      /* this graph has n nodes */
            if (dist[k][i] != 0 && state[i].label == tentative) 
                if (state[k].length + dist[k][i] < state[i].length) {
                     state[i].predecessor = k;
                     state[i].length = state[k].length + dist[k][i];
                }

        /* Find the tentatively labeled node with the smallest label. */
        k = 0;
        min = INFINITY;

        for (i = 0; i < n; i++)
            if (state[i].label == tentative && state[i].length < min) {
                min = state[i].length;
                k = i;
            }

        state[k].label = permanent;
    } while (k != s);

    /*  Copy the path into the output array. */
    i=0;
    k=s;

    do {
        path[i++] = k;
        k = state[k].predecessor;
    } while (k >= 0);

} /* End of shortestpath */
            

Példa a Dijkstra algoritmusra: 

Az "A"-ból a "D"-be vezető optimális utat keressük. A gáfcsúcspontokhoz feljegyezzük, hogy "A"-ból mely szomszédján keresztül, s milyen költséggel érhető el ("A"-t tekintjük a fa gyökerének). Ahol nem szerepel jelzés, az azt jelenti, hogy még nem találtunk oda vezető utat (elérhetetlennek tekintjük a gráfcsúcspontot). A ponttal jelzett gráfcsúcspont az adott gráfcsúcspont "lezárt" állapotát jelzi. Ez azt jelenti, hogy a gráfcsúcspontba vezető legjobb utat már megtaláltuk, s megvizsgáltuk, hogy az adott gráfcsúcspontból merre lehet továbblépni optimális úton haladva.

A nyíllal jelölt gráfcsúcspont az ún. "aktuális" pont, erre vonatkozóan vizsgáljuk, hogy milyen (nem zárt) továbblépési lehetőségek vannak innen. Kiinduló helyzetben az "A" gráfcsúcspont az aktuális pont.