Esercizio 1 (6 punti)

Transcript

1 Prova scritta del 22 gennaio 2018 di Fondamenti di Informatica II (prof. Di Gaspero) Per studenti di Ing. Gestionale immatricolati negli anni accademici e precedenti DURATA DELLA PROVA: 2 ORE A pena di annullamento immediato della prova: 1) Non è possibile consultare libri o appunti (in qualunque forma) né utilizzare calcolatrici, telefoni cellulari, ecc. 2) Non è consentito comunicare (con qualunque mezzo) 3) Non è consentito uscire dall aula Esercizio 1 (6 punti) Dato la coda di priorità q implementata come heap tree rappresentata implicitamente nel vettore riportato a lato. 1. disegnare la sua rappresentazione schematica in forma di albero binario; 2. simulare l operazione dequeue(q) illustrandone i diversi passaggi. Esercizio 2 (12 punti) Si consideri un nuovo tipo di dato astratto lista_multipla che consiste di un vettore (creato dinamicamente, ma di dimensione fissa) di liste di valori di tipo int. Il peso di ciascuna delle liste che costituiscono una lista multipla è dato dalla somma dei suoi valori. Si veda l esempio a fianco di una lista multipla che consiste di 4 liste e in cui il peso della prima lista è 4, quello della seconda 4, della terza 0 e della quarta 6. Le operazioni possibili sulle liste multiple sono le seguenti: lista_multipla crea_lista_multipla(int m): crea un vettore di m liste inizialmente vuote e imposta eventuali altre informazioni nel descrittore; inserisci_lista_multipla(lista_multipla *lm, int d): inserisce il dato d nella lista, facente parte della lista multipla lm, avente peso minore; rimuovi_lista_multipla(lista_multipla *lm, int d): rimuove tutte le occorrenze del dato d dalle liste facenti parte della lista multipla lm; elimina_lista_multipla(lista_multipla *lm): elimina la lista multipla deallocando tutti i dati allocati dinamicamente. 1. Si definisca un possibile descrittore per il tipo di dato lista multipla (in altre parole la struct _lista_multipla). 2. Si implementino in linguaggio C le operazioni di manipolazione delle liste multiple descritte in precedenza. Qualora fosse necessario si assuma l esistenza di funzioni di manipolazione delle liste adattate allo specifico tipo di informazione memorizzata nelle singole liste (ad es. aggiungi_in_testa(lista* l, int dato), nodo_lista* trova_dato(nodo_lista *t, int dato)). In tal caso, si scrivano le dichiarazioni delle funzioni utilizzate. 3. Si discuta, informalmente, la complessità temporale dell implementazione delle operazioni di manipolazione espressa in funzione di n, numero totale di elementi memorizzati in tutte le liste, e di m, numero totale di liste.

2 #include <stdlib.h> typedef struct _nodo_lista { int dato; struct _nodo_lista* succ; nodo_lista; // una possibilità è mantenere due array, uno con il peso e l'altro con i puntatori ai nodi, oppure si potrebbe racchiudere tutto in un singolo record nodo_lista** liste; int* peso; int m; lista_multipla; // complessità O(m): dovuto al ciclo for lista_multipla crea_lista_multipla(int m) { lista_multipla lm; lm.liste = (nodo_lista**)malloc(m * sizeof(nodo_lista)); lm.peso = (int*)malloc(m * sizeof(int)); assert(lm.liste!= NULL && lm.peso!= NULL); for (i = 0; i < m; i++) { lm.liste[i] = NULL; lm.peso[i] = 0; lm.m = m; return lm;

3 // complessità O(m + n): ciclo for seguito poi dalla scansione della lista di peso minore (che però, nel caso peggiore potrebbe avere lunghezza n) void inserisci_lista_multipla(lista_multipla* lm, int d) { int i, i_min = 0; nodo_lista* n; for (i = 1; i < lm->m; i++) if (lm->peso[i] < lm->peso[i_min]) i_min = i; n = (nodo_lista*)malloc(sizeof(nodo_lista)); assert(n!= NULL); n->dato = d; n->succ = lm->liste[i_min]; lm->liste[i_min] = n; lm->peso[i] += d; // complessità O(m + n): ciclo for al cui interno vi è la deallocazione degli elementi della lista con valore d (complessivamente n) void rimuovi_lista_multipla(lista_multipla* lm, int d) { nodo_lista *c, *p, *n; for (i = 0; i < lm->m; i++) { p = NULL; c = lm->liste[i]; while (c!= NULL) { n = c->succ; if (c->dato == d) { if (p == NULL) else c = n; lm->liste[i] = c->succ; p->succ = c->succ; free(c); lm->peso[i] -= d;

4 // complessità O(m + n): analogamente al precedente, ciclo for al cui interno vi è la deallocazione di tutti gli elementi della lista (complessivamente n) void elimina_lista_multipla(lista_multipla* lm) { nodo_lista *c, *p; for (i = 0; i < lm->m; i++) { c = lm->liste[i]; while (c!= NULL) { p = c->succ; free(c); c = p; free(lm->liste); free(lm->peso); Esercizio 3 (12 punti) Analogamente alla rappresentazione implicita di uno heap tree, è possibile rappresentare anche un albero binario di ricerca (ABR) attraverso un opportuno array. La differenza principale è costituita dal fatto che nel caso un ABR non è necessariamente completo a sinistra, per cui alcune delle celle dell array potrebbero riferirsi a dei nodi non presenti nell albero (si veda l esempio nella figura seguente). 1. Si proponga un possibile descrittore albero_binario_in_array per memorizzare le informazioni necessarie a questo tipo di rappresentazione. 2. Si simuli l operazione di inserimento dei valori chiave = 32, dato = 0.5 nell albero e nella sua rappresentazione in array (suggerimento: che operazione è necessaria sull array nel caso di introduzione di un nuovo livello?); 3. Si discuta, informalmente, la complessità spaziale necessaria per la memorizzazione di un ABR costituito da k livelli utilizzando questa rappresentazione. 4. Si implementi in pseudocodice o in linguaggio C la funzione inserisci_albero_binario_in_array(albero_binario_in_array* a, int chiave, float dato). Qualora fosse necessario si assuma l esistenza di funzioni di manipolazione delle strutture dati utilizzate adattate allo specifico tipo di informazione memorizzata. In tal caso, si scrivano le dichiarazioni delle funzioni utilizzate. #include <stdbool.h> #include <math.h> #include <assert.h> #include <stdlib.h> int chiave; float dato; bool presente; nodo_albero_binario_in_array; int k; int d; nodo_albero_binario_in_array* nodi; albero_binario_in_array;

5 // per memorizzare un ABR costituito da k livelli sono necessari 2^k - 1 locazioni int _figlio_sx(int i) { return 2 * i + 1; int _figlio_dx(int i) { return 2 * i + 2; // complessità O(k), con k il numero di livelli dell'albero (sfortunatamente potrebbe essere O(n)) int dove_inserire(nodo_albero_binario_in_array* nodi, int i, int d, int chiave) { // il primo caso base avviene se i è dentro le dimensioni dell'array e il dato // in posizione i non è ancora presente if (i < d &&!nodi[i].presente) return i; // il secondo caso base avviene se i è fuori dall'array, in tal caso, ovviamente, // l'elemento a[i] non è presente e può essere inserito nella posizione i previa // estensione dell'array if (i >= d) return i; // i casi ricorsivi, invece, si hanno quando l'elemento in posizione a[i] è già presente if (chiave < nodi[i].dato) return dove_inserire(nodi, _figlio_sx(i), d, chiave); else return dove_inserire(nodi, _figlio_dx(i), d, chiave); // complessità O(k + 2^{k - 1), con k il numero di livelli dell'albero void inserisci_albero_binario_in_array(albero_binario_in_array* a, int chiave, float dato) { int i = dove_inserire(a->nodi, 0, a->d, chiave), j; if (i >= a->d) { // se la locazione in cui inserire è più grande di n, allora bisognerà estendere // l'albero di un livello a->d = pow(2, a->k + 1) - 1; a->k = a->k + 1; a->nodi = (nodo_albero_binario_in_array*)realloc(a->nodi, a->d * sizeof(nodo_albero_binario_in_array)); assert(a->nodi); for (j = a->d / 2; j < a->d; j++) // il numero di iterazioni è pari a 2^{k - 1 a->nodi[j].presente = false; assert(!a->nodi[i].presente); // per verificare che la locazione sia effettivamente libera a->nodi[i].chiave = chiave; a->nodi[i].dato = dato;