Dijkstra calcola il percorso a costo minimo da un nodo (l'origine, che chiameremo ) a tutti gli altri nodi della rete. L'algoritmo è iterativo e ha le seguenti proprietà: dopo la -esima iterazione, i percorsi a costo minimo sono noti verso nodi di destinazione e, tra i percorsi a costo minimo verso tutti i nodi di destinazione, questi percorsi hanno i costi più bassi. Vediamo di capire bene cosa vuol dire questa affermazione: avendo un certo di nodi nel grafo e data un origine , dopo un certo numero di iterazioni dell'algoritmo di Dijkstra, diciamo , saranno stati trovati percorsi minimi da verso nodi di destinazione, se nelle iterazioni precedenti fossero stati trovati altri percorsi da verso questi nodi, dopo iterazioni siamo sicuri che quelli minimi attualmente trovati sono effettivamente minimi entro la -esima iterazione.
Adotteremo la seguente notazione:

• : costo minimo del percorso dal nodo origine alla destinazione per quanto concerne l'iterazione corrente dell'algoritmo.
• : immediato predecessore di lungo il percorso a costo minimo dall'origine a .
• : sottoinsieme di nodi contenente tutti (e solo) i nodi per cui il percorso a costo minimo dall'origine a è definitivamente noto.

L'algoritmo di instradamento centralizzato consiste in un passo di inizializzazione seguito da un ciclo che viene eseguito una volta per ogni nodo del grafo. Quando termina, l'algoritmo avrà calcolato il percorso minimo dal nodo origine a tutti gli altri nodi.

Inizializzazione:
 N' = {u}
 per tutti i nodi v
	se v è adiacente a u
		allora D(v) = c(u,v)
	altrimenti D(v) = infinito

Ciclo
 determina un w non in N' tale che D(w) sia minimo
 aggiungi w a N'
 aggiorna D(v) per ciascun nodo v adiacente a w e non in N'
		  D(v) = min(D(v), D(w) + c(w,v))
 /* il nuovo costo verso v è il vecchio costo verso v oppure il costo del costo del
    del percorso minimo noto verso w più il costo da w a v */
 ripeti il ciclo fino a che non si verifica N' = N
Copy

Esecuzione dell'algoritmo sulla rete della figura sopra: diciamo di voler conoscere tutti percorsi che vanno dal router al router .
inizialmente contiene solo .

Per tutti i nodi che sono adiacenti (vicini) a allora segniamo la distanza nota tra e i nodi vicini. In questo caso i vicini sono , e , rispettivamente con i costi , e . I costi verso e sono posti all'infinito .
Nella prima iterazione prendiamo in considerazione i nodi non ancora aggiunti all'insieme e determiniamo il nodo a costo minimo che è , aggiungiamo a .
Considereremo una tabella come quella che segue, in cui abbiamo il passo dell'algoritmo e le distanze note da tutti i nodi e in cui indichiamo anche il predecessore immediato al nodo specificato nella colonna corrente.

Una volta appurato che è il nodo più vicino a , lo aggiungiamo a e aggiorniamo le distanze.
Infatti da si possono raggiungere tre nodi:

• con distanza
• con distanza
• con distanza
  A questo punto dobbiamo confrontare il peso del percorso di cui è già nota la distanza con il peso del percorso se fosse raggiunto da .
  La distanza da attualmente segnata è , da è , in questo caso il percorso per raggiungere passando da non è conveniente, allora lo si lascia com'è.
  La distanza da attualmente segnata è , da è , , in questo caso il percorso per raggiungere passando da è più conveniente allora va aggiornato.
  La distanza da attualmente segnata è , da è che è sicuramente minore di infinito, per cui anche questo va aggiornato.

A questo punto va scelto il percorso minimo, tra quelli attualmente noti.
Teniamo presente che è stato ispezionato e che non è da considerare tra le scelte.
Due percorsi minimi hanno lo stesso valore e sono i percorsi verso e verso entrambi con peso .
Possiamo sceglierne uno a caso tra i due, diciamo e lo aggiungiamo a .
è collegato a due nodi:

• con distanza
• con distanza
  La distanza attualmente nota per è , da sarebbe che risulta essere inferiore a , va aggiornato.
  La distanza attualmente nota per è da sarebbe che risulta essere inferiore a infinito, va aggiornato.

L'algoritmo continua così fino a che non si ottiene che .
L'algoritmo finito mostra la seguente tabella:

quando Dijkstra finisce, abbiamo per ciascun nodo il suo predecessore lungo il percorso a costo minimo dal nodo origine. Per ciascun predecessore abbiamo il rispettivo predecessore, e in questo modo riusciamo a costruire l'interno percorso dall'origine a tutte le destinazioni. La tabella di inoltro di un nodo, diciamo , può essere ricostruita da queste informazioni memorizzando, per ciascuna destinazione, il nodo del successivo hop sul percorso a costo minimo da alla destinazione.

La figura sopra mostra i percorsi a costo minimo risultati dal grafo fornito inizialmente.
La complessità di Dijkstra è .
Un'implementazione dell'algoritmo che sfrutta la struttura dati heap riesce a determinare il minimo della riga 9 (determina un w non in N' tale che w sia minimo) in tempo logaritmico anziché lineare riducendone la complessità totale.