LINK FORMS

Parte Algoritmi

https://forms.office.com/Pages/ResponsePage.aspx?id=K3EXCvNtXUKAjjCd8ope612l9yEARrZBj
hLl1lBueNxUQjJORFlXUllFRExVSzY2U0VFQTkxTE1UQS4u

Parte Informatica Teorica

https://forms.office.com/Pages/ResponsePage.aspx?id=K3EXCvNtXUKAjjCd8ope6xGhEotCVVtK
rA8eYdjna3RUQ1pGMk1HMlpENkkyTzhMVERPMzRIN0NWTS4u

Recuperi

https://forms.office.com/Pages/ResponsePage.aspx?id=K3EXCvNtXUKAjjCd8ope6xGhEotCVVtK
rA8eYdjna3RUMUJWM1JNQVlEVjFTQVJEVVo1TjFVREhVRi4u

SOLUZIONI PARTE ALGORITMI – API – GIUGNO 2020

ESERCIZIO TABELLA DI HASH

Si vuole costruire una tabella di hash a partire dalla seguente sequenza di chiavi:

5, 10, 37, 63, 40, 77, 70, 96

Si ipotizzi che la dimensione della tabella di hash sia m = 11 e che la funzione di hash da
applicare sia h(k) = k mod 11. Si supponga che i primi 6 valori siano già stati inseriti e che sia
stato ottenuto

[77, _, _ , _, 11, 5, _, 40, 63, _, 10]

Si inseriscano gli ultimi due valori nella posizione corrette ipotizzando che la politica di
risoluzione delle collisioni sia double hashing con h’(k) = 1 + k mod 10

Si riporti l’array finale, specificato nello stesso formato riportato sopra e i calcoli e i passi principali per
risolvere l’esercizio.
SOLUZIONE

[77, _, _ , 96, 11, 5, 70, 40, 63, _, 10]

h(70) = 70 mod 11 = 4 OCCUPATA

h’(70) = 1 + (70 mod 10) = 1

4+1=5 OCCUPATA

4+2=6 LIBERA

h(96)= 96 mod 11=8 OCCUPATA

h’(96) = 1 + (96 mod 10) = 7

(8+7)mod 11= 4 OCCUPATO

(8+14)mod 11= 0 OCCUPATO

(8+21) mod 11=7 OCCUPATO

(8+28)mod 11=3 LIBERA

ESERCIZIO VISITA GRAFO

Si consideri il grafo orientato rappresentato dalla seguente lista di adiacenza

Si scriva il risultato della visita in ampiezza che si ottiene partendo dal nodo 4

Si scriva il risultato della visita in profondità che si ottiene partendo dal nodo 0

SOLUZIONE

Ampiezza da 4: 4-3-5-2-0 poi l’algoritmo di visita verifica se ci sono nodi non ancora visitati e riprende la
visita da lì; in questo caso troverebbe 1

Profondità da 0: 0-1-3-5-2-4

Nota: l’ordine con cui vengono visitati i nodi è dato dall’ordine delle liste di adiacenza
ESERCIZIO ALBERO

Si consideri un albero binario contenente valori interi positivi. Si scriva una funzione C++ che riceve in
ingresso la radice di un albero binario e un intero k>0 e restituisca il prodotto dei valori che si trovano dal
livello k in poi; se non sono presenti valori al livello k la funzione restituirà 0.

SOLUZIONE

Una possibile soluzione consiste nell’effettuare il prodotto di tutti i valori nei nodi di livello >=k
e di tenere in una variabile l’informazione sul fatto che il livello k è stato raggiunto almeno una
volta. Se non viene raggiunto si restituisce 0.

template <class Elem>

int preorder(BinNode<Elem>* subroot, int k, int livello, int & k_raggiunto) {

if (subroot == NULL)

return 1; // non cambia il prodotto

int prodotto;

if (livello>=k)

{prodotto= subroot->value(); k_raggiunto=1;}

else prodotto=1;

livello++;

prodotto=prodotto*preorder(subroot->left(), k, livello, k_raggiunto); // L

prodotto=prodotto*preorder(subroot->right(), k, livello k_raggiunto); // R

return prodotto;

Il main verificherà se k_raggiunto è pari a 1 (sarà inizializzato a 0) e in quel caso considererà il

valore ottenuto dalla funzione.
In alternativa si può restituire una struct con due valori oppure passare due valori (prodotto e
k_raggiunto) per indirizzo.

Un algoritmo proposto da un vostro compagno utilizza un paio di variabili globali per capire se è
stato raggiunto il livello k e la prima volta che si trova un nodo a livello k si pone la variabile
risultato del prodotto pari a 1 (altrimenti è inizializzata a 0):

l = 0; result = 0; first = true;

int productK (Node* subroot, int k, int l){

if (subroot == NULL){

return;

if (l >= k){

if (first){

result += 1;

first = false;

result *= subroot -> value;

productK(subroot -> left(), k, l+1);

productK(subroot -> right(), k, l+1)

il risultato sarà nella variabile result