Albero binario di ricerca bilanciato implementato su array - balanced bst on array

Nioi Pier Giuliano Università degli Studi di Cagliari

Corso di Laurea in Tecnologie InformaticheAlgoritmi e Strutture Dati 2

Rappresentazione mediante array di un

balanced BST

• Dato un insieme di elementi, ordinato in ordine crescente, è possibile costruire e rappresentare un albero binario di ricerca su array, in modalità bottom-up.

• Questa rappresentazione consente di risparmiare lo spazio che verrebbe invece occuppato dai puntatori in una rappresentazione ‘collegata’ dell’albero binario di ricerca.

• Il nostro BST memorizzerà i valori nelle foglie mentre nei nodi interni si valorizzeranno delle chiavi per condurre la ricerca.Nioi Pier Giuliano

Università degli Studi di CagliariCorso di Laurea in Tecnologie Informatiche

Algoritmi e Strutture Dati 2

• Dato l’array

contenente 5 elementi, usualmente lo si rappresenta in modalità ‘collegata’ o ‘linkata’ in un albero binario bilanciato, avente queste sembianze:

1 2 3 4 5

3

2 4

1

1 2

3 4 5



• L’albero è costituito da 3 livelli(la radice è al livello 0)

• Ha 5 foglie e 4 nodi interni• Formalmente ha n foglie e n-1

nodi interni• È un albero completo e bilanciato• Il numero di foglie è compreso tra 2i e 2i+1, cioè il

numero massimo di foglie per un albero di livello i, cosiddetto pieno

• In questo caso abbiamo 22 < 5 < 23, ovvero che 4 < 5 < 8

3

2 4

1

1 2

3 4 5



lvl 0

lvl 1

lvl 2

lvl 3

• Per rappresentare tale albero su array, utilizziamo la stessa rappresentazione che si utilizza con gli heap(max o min)

• Un nodo alla posizione i di un vettore, avrà il suo figlio sinistro alla posizione 2*i e il suo figlio destro alla posizione 2*i +1, mentre ogni figlio avrà il suo padre alla posizione floor(i/2)

• Il nostro albero binario su array dovrà essere costituito da (n-1)+n+1 locazioni, (nodi interni)+ foglie+1

• Il +1 finale, riguarda la prima locazione

3

2 4

1

1 2

3 4 5Nioi Pier Giuliano



• Possedendo già un albero binario in modalità linkata, è possibile trasferirlo su array, facendo valere le proprietà della slide precedente, con un semplice attraversamento dell’albero fatto per livelli

• Ovvero

la radice ha posizione 1 e i suoi figli e sono alla posizione 2*1=2 e

2*1+1=3 .

3

2 4

1

1 2

3 4 5Nioi Pier Giuliano



3 2 4 1 3 4 5 1 2

3

2 4

• Ma come costruirlo bottom-up a partire da un array di elementi ordinato in ordine crescente, senza dover creare strutture ‘linkate’ di appoggio?

• Sicuramente il risultato finale sarà identico a quello prodotto mediante visita per livelli di una struttura linkata di appoggio, ovvero avremmo bisogno dello stesso numero di locazioni

• È relativamente semplice, a patto di risolvere un problema: il nostro vettore ordinato è presente nell’array finale del BST, ma in maniera diversa



• Notare l’ordine degli elementi

• Le foglie non sono memorizzate in ordine crescente ‘continuo’, ma spezzettato

• Questo fatto riflette la disposizione delle foglie a diversi livelli dell’albero

• Bisogna perciò capire come e quali elementi del nostro array ordinato dobbiamo spostare



1 2 3 4 5

3 2 4 1 3 4 5 1 2

• Per fare questo ci aiuta una ‘strana’ caratteristica dell’albero e il suo legame con il log2 e le potenze di 2 citate ad inizio presentazione

• Si è detto che “Il numero di foglie è compreso tra 2i e 2i+1”, cioè abbiamo che le nostre foglie stanno a ‘cavallo’ tra una rappresentazione piena di livello i e una di livello i+1

• Dobbiamo capire quali nodi della rappresentazione di livello i, vengono ‘promossi’ ad una rappresentazione di livello successivo



• Nel nostro caso abbiamo che 22 < 5 < 23 , ovvero che 4 < 5 < 8

• Dalla figura notiamo che solo un nodo della rappresentazione di livello i ( in questo caso 2) viene promossa a nodo interno per favorire la rappresentazione di livello i+1( in questo caso 3)

• Se facciamo 5-4, otteniamo il numero di nodi che diventeranno nodi interni, che verranno cioè promossi, ovvero 1 soltanto, che avrà 2 figli



3

2 4

1

1 2

3 4 5

• Questo 2, rappresenta il numero di elementi da portare da testa a coda del nostro array di elementi ordinati

• E cosi facendo otteniamo proprio l’ordine con la quale ci interessa affrontare l’ultima parte della costruzione del BST, ovvero la costruzione bottom-up



1 2 3 4 5

3 4 5 1 2

3 2 4 1 3 4 5 1 2

• Prima però bisogna chiarire come ricavare il nostro 4, senza avere nessuna conoscenza di quanti livelli ci siano nel nostro futuro albero

• È arrivato il momento di fare uso del log2

• Noi possediamo solo il numero degli elementi del nostro array ordinato in ordine crescente, che è 5 (formalmente n)

• Usando il logaritmo e l’operatore floor() troviamo il nostro valore ricercato, rappresentante il livello i



• log2 5 = 2.3219...

• floor(log2 5) = 2• Ora abbiamo il numero di livello i ricercato• Per sapere quanti nodi ci sono al livello i,

usiamo le potenze di 2, ovveronumeroNodi= 2floor(log2 n) = 2floor(log2 5) = 22 = 4

• Ed ecco il nostro 4!

• Ora affrontiamo l’ultima fase di costruzione del BST



• Creiamo un array di grandezza pari alla somma del numero di nodi interni + foglie + 1, nel nostro caso 9, e mettiamo in coda il nostro vettore in input, opportunamente suddiviso



1 2 3 4 5

3 4 5 1 2

--- 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

• Per ogni celletta libera, dal fondo verso la cima, dobbiamo ricercare il valore corretto che farà da guida durante la ricerca nell’array

• Se il ‘nodo’ alla posizione i non ha nipoti, ma solo figli, si prende il valore del figlio sinistro, cioè il più piccolo

• Altrimenti si va a ricercare il nipote più grande del figlio sinistro del nodo alla posizione i



--- 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

• Posizione 4, ha solo figli

• Idem posizione 3.



--- 1 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

--- 4 1 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

• Posizione 2, ha nipoti

• Idem per la posizione 1( root )



--- 2 4 1 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

--- 3 2 4 1 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

• Una costruzione di questo tipo, che si occupa di inserire il valore chiave per effettuare le ricerche, produce l’array desiderato, avente le proprietà di una memorizzazione su array come per l’heap e un notevole risparmio di memoria in puntatori inutilizzati grazie all’uso di formule per ricavare i figli sinistro e destro e il relativo padre



--- 3 2 4 1 3 4 5 1 2

0 1 2 3 4 5 6 7 8 9

3 2 4 1 3 4 5 1 2 3

2 4

1

1 2

3 4 5

Fine



Education

Albero binario di ricerca bilanciato implementato su array - balanced bst on array