L'idea di base è la seguente:
ciascun nodo inizia con , una stima del costo del percorso a costo minimo da se stesso al nodo , per tutti i nodi in . Sia il vettore delle distanze del nodo , che è il vettore delle stime dei costi da a tutti gli altri nodi, , in . Con l'algoritmo di Bellman-Ford, ciascun nodo mantiene i seguenti dati di instradamento.

• Per ciascun vicino , il costo da al vicino .
• Il vettore delle distanze del nodo , che è , contenente la stima presso del costo verso tutte le destinazioni, , in .
• I vettori delle distanze di ciascuno dei suoi vicini, ossia , per ciascun vicino di .
  In questo algoritmo distribuito e asincrono, di quando in quando un nodo invia una copia del proprio vettore delle distanze a ciascuno dei suoi vicini. Quando un nodo riceve un nuovo vettore da qualcuno dei suoi vicini , lo salva e quindi usa la formula di Bellman-Ford per aggiornare il proprio vettore come segue:
  per ciascun nodo in .
  Se il vettore delle distanze del nodo è cambiato per via di tale passo di aggiornamento, il nodo x manderà il proprio vettore aggiornato a ciascuno dei suoi vicini, i quali a loro volta aggiorneranno il proprio vettore. Cosa piuttosto miracolosa, finché tutti i nodi continuano a cambiare i proprio vettore delle distanza in maniera asincrona, ciascuna stima dei costi converge a , l'effettivo costo del percorso a costo minimo dal nodo al nodo .

A ciascun nodo x:
 Inizializzazione:
	per tutte le destinazioni y in N:
		D_x(y) = c(x,y) // se y non è adiacente allora c(x,y) = infinito
	per ciascun vicino w di x
		D_w(y) = ? per tutte le destinazioni y in N
		// in quanto non sono note le distanze tra i vicini w di x
		// e gli altri nodi y in N
	per ciascun vicino w
		inva il vettore delle distanxe D_x = [D_x(y): y in N] a w

 Ciclo
	 attendi (fino a che vedi cambiare il costo di uno collegamento verso
			 qualche vicino w o fino a che ricevi un vettore delle distanze
			 da qualche vicino w)
	 per ogni y in N:
		 D_x(y) = min_v(c(x,v) + D_v(y)) (***)
	 
	 se D_x(y) è cambiato per qualche destinazione y
		 invia il vettore delle distanze D_x = [D_x(y): y in N] a tutti i vicini

 ripeti ciclo indefinitamente
Copy

L'algoritmo di Bellman-Ford mostra come un nodo aggiorni la propria stima del vettore delle distanze quando vede il cambiamento di costo in uno dei collegamenti direttamente connessi o quando riceve da qualche vicino un vettore aggiornato. Tuttavia per aggiornare la propria tabella di inoltro per una data di destinazione , ciò che il nodo ha davvero bisogno di sapere non è la distanza sul percorso minimo verso , bensì il nodo vicino che rappresenta il router successivo lungo il percorso più breve verso . Come ci si potrebbe aspettare , il router è il vicino che ottiene il valore minimo nella riga (***) dell'algoritmo. Se esistono più vicini che ottengono il minimo, allora può essere uno qualunque tra questi. Pertanto nelle riga (***), per ciascuna destinazione il nodo determina anche e aggiorna la propria tabella di inoltro per la destinazione .

L'algoritmo di Bellman-Ford a differenza di quello di Dijkstra (e l'instradamento Link-State in generale) è decentralizzato. In Dijkstra è necessario che ciascun nodo della rete riceva una mappa della rete, prima di cominciare l'esecuzione dell'algoritmo.
Le sole informazioni possedute dai nodi in Bellman-Ford sono il costo dei collegamenti verso i vicini direttamente connessi e quelle ricevute da questi vicini. Ogni nodo attende aggiornamenti dai suoi vicini, quando li riceve (nell'algoritmo attendi (fino a che vedi cambiare...)) e li distribuisce ai suoi vicini (invia il vettore delle distanze D_x = ...).
L'instradamento DV viene utilizzato in molti protocolli reali tra cui RIP e BGP per Internet, ISO IDRP, IPX di Novell e ARPAnet originale.

Il funzionamento dell’algoritmo viene mostrato in modo sincrono, in quanto tutti i nodi ricevono simultaneamente i vettori delle distanze dai propri vicini, calcolano i rispettivi nuovi vettori e informano i vicini degli eventuali cambiamenti. Dopo aver studiato questo esempio vi dovreste convincere che l’algoritmo opera correttamente anche in modo asincrono, con calcoli ai nodi, generazione e ricezione di aggiornamenti in qualsiasi istante.

La colonna di sinistra mostra tre tabelle di instradamento (routing table) iniziali per ciascuno dei tre nodi. All’interno di una specifica tabella di instradamento le righe rappresentano i vettori delle distanze: più precisamente, la tabella di instradamento di ciascun nodo include il proprio vettore delle distanze e quello dei suoi vicini.
Pertanto, la prima riga nella tabella di instradamento iniziale del nodo è .
La seconda e la terza riga di questa tabella rappresentano i vettori delle distanze ricevuti più di recente rispettivamente dai nodi e , i valori della seconda e della terza riga sono posti a infinito all'inizio.

Dopo l’inizializzazione, ciascun nodo invia il proprio vettore ai suoi vicini come
mostrato dalle frecce dalla prima alla seconda colonna delle tabelle.
Per esempio, il nodo invia il suo vettore delle distanze ai nodi e .
Dopo aver ricevuto gli aggiornamenti, i nodi ricalcolano il vettore delle distanze. Per esempio, il nodo calcola:

• 
  La seconda colonna pertanto mostra, per ciascun nodo, il nuovo vettore delle distanze del nodo e i vettori delle distanze appena ricevuti dai suoi vicini.
  Notiamo, per esempio, che la stima del nodo per il costo minore verso il nodo , , è passata da a , e che il nodo ottiene i valore minimo alla riga (***) dell’algoritmo Bellman-Ford; quindi, a questo stadio dell’algoritmo, per il nodo , e .
  Dopo aver ricalcolato i rispettivi vettori delle distanze, i nodi li inviano in versione aggiornata ai propri vicini (ammesso che siano cambiati), procedura indicata nella figura con le frecce dalla seconda colonna alla terza. Notiamo che solo i nodi e inviano aggiornamenti: il vettore delle distanze del nodo non è cambiato e pertanto non è stato spedito. Dopo la ricezione degli aggiornamenti, i nodi ricalcolano i propri vettori delle distanze e aggiornano le tabelle di instradamento (terza colonna). Il processo di aggiornamento dei vettori continua fino a che non viene inviato più alcun messaggio di aggiornamento, l'algoritmo entra in uno stato di quiete, da cui esce solo se cambia il costo di un collegamento (e di conseguenza viene inviato messaggio contenente tale aggiornamento).

Quando un nodo che esegue l’instradamento DV rileva un cambiamento nel costo dei collegamenti con un vicino aggiorna il proprio vettore delle distanze e, se si verifica un cambiamento nel costo del percorso a costo minimo, trasmette ai suoi vicini il proprio nuovo vettore delle distanze. La figura di seguito mostra uno scenario in cui avviene il cambiamento del costo di un collegamento passando da 4 a 1.

Ci concentreremo solo su e sulle righe della tabella delle distanze di verso la destinazione . L'algoritmo provoca la seguente sequenza di eventi:

• all'istante , il router rileva il cambiamento nel costo del collegamento (passato da 4 a 1), aggiorna il proprio vettore delle distanze e informa i vicini del cambiamento.
• All'istante , il router riceve l'aggiornamento da e aggiorna la propria tabella, calcola un nuovo costo minimo verso (che passa da 5 a 2) e invia il nuovo vettore delle distanze ai vicini.
• All'istante , il router riceve l’aggiornamento di e aggiorna la propria tabella delle distanze.
  I costi minimi di non cambiano e non manda alcun messaggio a . L’algoritmo entra in uno stato quiescente.
  Pertanto, dopo due iterazioni l’algoritmo raggiunge uno stato di quiete.

Prendiamo in considerazione ora che cosa può avvenire quando il costo di un collegamento aumenta. Supponiamo che il costo del collegamento tra x e y passi da 4 a 60.

1. Prima che il costo del collegamenti cambi:
   • 
     All'istante , il nodo rileva che il costo del collegamento è passato da 4 a 60 e calcola il suo nuovo percorso a costo minimo verso con la formula: Ovviamente, con la nostra visione globale della rete, possiamo rilevare che questo nuovo costo attraverso è errato. Ma l’unica informazione che il nodo possiede è che il costo diretto verso è 60 e che ha ultimamente detto a di essere in grado di giungere a con un costo di 5. Pertanto al fine di arrivare a , il nodo adesso farebbe passare il percorso per , aspettandosi che questo sia in grado di giungere a con un costo pari a 5.
     All'istante , abbiamo un instradamento ciclico: al fine di giungere al nodo , il nodo fa passare il percorso per e lo fa passare per .
     In un instradamento ciclico: un pacchetto destinato a che arriva a o all'istante rimbalzerà avanti e indietro tra questi due nodi per sempre (a meno che non vengano cambiate le tabelle di inoltro).
2. Dato che il nodo ha calcolato un nuovo costo minimo verso , informa del suo nuovo vettore delle distanze all’istante .
3. In un istante successivo a , riceve il nuovo vettore delle distanze di , che indica che il costo minimo di verso è 6, sa che può giungere a con costo 1 e quindi calcola un nuovo costo minimo verso pari a . Dato che il costo minimo di verso è aumentato, informa del suo nuovo vettore delle distanze al tempo .
4. Analogamente, dopo aver ricevuto il nuovo vettore delle distanze di , il nodo determina e invia a il suo nuovo vettore delle distanze. Il nodo allora determina e invia a il suo nuovo vettore delle distanze, e così via.

Lo scenario appena descritto può essere evitato utilizzando una tecnica nota come poisoned reverse.
L'idea è semplice: se instrada tramite per giungere alla destinazione , allora avvertirà che la sua distanza verso è infinita, anche se in realtà non è vero.
Dato che crede che non abbia un percorso verso , non tenterà mai di instradare verso passando per , per tutto il tempo in cui continua a instradare verso passando per (e mente a riguardo).

Vediamo come viene risolto il problema dei cicli che abbiamo incontrato nella figura:

utilizzando la tecnica dell'inversione avvelenata.
Come risultato dell'inversione avvelenata la tabella di distanza indica , poiché instrada i pacchetti con destinazione tramite .
Quando il costo del collegamento cambia da 4 a 60 all'istante , il nodo aggiorna la propria tabella, continua a instradare direttamente verso nonostante sia il costo più alto (60), anche perché in quel momento sta ancora mentendo a dicendo che la sua distanza da è . Nel frattempo informa del suo nuovo costo verso , ossia .
Una volta ricevuto l’aggiornamento all’istante , cambia immediatamente il proprio percorso verso facendolo passare attraverso il collegamento diretto al costo 50.
Dato che questo è il nuovo percorso a costo minimo verso e dato che non passa più attraverso , ora informa che all’istante che . Dopo aver ricevuto l'aggiornamento da , adegua la propria tabella di distanza ponendo .
Dato che si trova ora sul percorso a costo minimo di verso , avvelena il percorso inverso da a informando all'istante che , anche se in realtà sa che .

Con DV ciascun nodo dialoga solo con i vicini direttamente connessi, informandoli delle stime a costo minimo da sé stesso a tutti i nodi che conosce nelle rete. Con LS invece, ciascun nodo dialoga con tutti gli altri nodi via broadcast, ma comunica loro solo i costi dei collegamenti direttamente connessi.
Ricordiamo che rappresenta l'insieme dei nodi (router) ed l'insieme degli archi del grafo inteso come rete.

• Complessità dei messaggi: LS richiede che ciascun nodo conosca il costo di ogni collegamento nella rete. Ciò implica l'invio di messaggi. Inoltre ogni volta che un collegamento cambia di costo, il nuovo costo deve essere comunicato a tutti i nodi.
  DV, ad ogni iterazione richiede scambi di messaggi tra nodi vicini. Il tempo richiesto affinché l'algoritmo converga dipende da diversi fattori. Quando cambiano i costi dei collegamenti, DV propaga i risultati dei costi cambiati se il nuovo costo ha causato la variazione del percorso a costo minimo per uno o più nodi connessi a tale collegamento.
• Velocità di convergenza. LS è un algoritmo con complessità computazionale di che richiede messaggi.
  DV può convergere lentamente e presentare cicli di instradamento. DV presenta anche il problema del conteggio all'infinito.
• Robustezza. Cosa succede se un router funziona male, si guasta o viene manomesso?
  Con LS, un router può comunicare via broadcast un costo sbagliato per uno dei suoi collegamenti connessi, o eliminare i pacchetti ricevuti in broadcast LS.
  Poiché ciascun router effettua in autonomia il calcolo della propria tabella di inoltro, e gli altri nodi effettuano calcoli simili per ciò che li riguarda, si verifica che i calcoli di instradamento vengono in qualche modo isolati, il che fornisce un certo grado di robustezza. Anche se un router dovesse inviare un risultato errato per un certo collegamento ad un altro router, in una iterazione successiva quell'errore viene corretto quando il router calcola il suo albero delle distanze.
  Con DV, invece, le distanza sui router adiacenti vengono fornite a tutti gli altri router, che salvano quelle informazioni e le inoltrano ai proprio vicini, propagando per tutta la rete un informazione non corrette che possono influenzare più collegamenti.
  In conclusione, nessuno dei due meccanismi di instradamento è nettamente superiore all’altro ed entrambi vengono utilizzati in Internet.