1

1/296

Algoritmi e Programmazione Avanzata - teoria

2/296

Che cosa c’è nella lezione

Questa lezione si occupa di strutture dati:

tipi di dato astratto

le pile

le code

le liste

gli alberi binari di ricerca

le tabelle di hash.

2

3/296

Algoritmi e Programmazione Avanzata - teoria

4/296

Tipo di Dato Astratto:

Definizione

Modello matematico sul quale è definito un insieme di operazioni.

3

5/296

Modello: insieme di elementi genericiOperazioni:

unione (X,Y)inters (X,Y)diff (X,Y)

Modello: intervallo di interiOperazioni:

+-*:

Esempio

6/296

Tipi primitivi: quelli supportati da un linguaggio (int, float, char per il C) con le loro operazioni (+, -, *, /, % etc.).

Tipi di Dati Astratti : estensione dell’insieme dei tipi di dato supportati.

Estensione dei tipi primitivi

4

7/296

nuove operazioni sui tipi primitivinuove operazioni su nuovi tipi

Tipi di Dato Astratto: associazione nuovo tipo ↔ nuovo insieme di operazioni.

Operatori: predefiniti, operazioni elementari sui tipi primitivi.

Procedure come estensione degli operatori:

Estensione

8/296

Definizione del Tipo di Dato Astratto indipendente da:

linguaggio di programmazione

scelta implementativa (struttura dati)

Implementazione

5

9/296

Definire in un file separato le procedure corrispondenti alle operazioni definite dal Tipo di Dato Astratto.

Definire un tipo di dato corrispondente al Tipo di Dato Astratto.

Lavorare sul Tipo di Dato Astratto esclusivamente utilizzando le procedure fornite.

Campi dato visibili solo attraverso le funzioni.

Implementazione in C

10/296

Esempio

Definizione del tipo:typedef SET_ELEM int;

Esempi di procedure:SET_ELEM *unione (SET_ELEM *, SET_ELEM *);SET_ELEM *inters(SET_ELEM *, SET_ELEM *);SET_ELEM *diff(SET_ELEM *, SET_ELEM *);SET_ELEM *make_null(void);int size (SET_ELEM *); void dump (SET_ELEM *);

6

11/296

Algoritmi e Programmazione Avanzata - teoria

12/296

Tipo di dato astratto con politica LIFO (Last In First Out) con operazioni:

Push: inserisce nuovo elemento nella pilaPop: estrae dalla pila l’ultimo elementoinseritoEmpty: vero se pila vuotaInit: crea nuova pila

Definizione

7

13/296

Esempio

Init()

14/296

Esempio

Push (K1)

K1

8

15/296

Esempio

Push (K2)

K1

K2

16/296

Esempio

Push (K3)

K1

K3

K2

9

17/296

Esempio

Pop

K1

K2 K3

18/296

Esempio

Pop

K1

K2

10

19/296

Vettore buff di N elementi

Variabile top: indice dell’ultimo elemento inserito

Complessità delle operazioni T(n) = O(1)

Implementazione tramite vettore

20/296

#define N 100int buff[N];int top;void push(int val);int pop(void);int empty(void);void push(int val) {

buff[++top] = val;return;

}

Implementazione C 1/2

11

21/296

int pop(void) {

return(buff[top--]);}int empty(void){

if(top == 0)return (1);

elsereturn (0);

}

Implementazione C 2/2

22/296

Algoritmi e Programmazione Avanzata - teoria

12

23/296

Tipo di dato astratto con politica FIFO (First In First Out) con operazioni:

Enqueue: inserisce un nuovo elementonella codaDequeue: estrae dalla coda il primo elemento inserito Empty: vero se coda vuotaInit: crea nuova coda.

Definizione

24/296

Esempio

Init()

Dequeue Enqueue

13

25/296

Esempio

K1

Dequeue Enqueue

Enqueue(K1)

26/296

Esempio

K1

Dequeue Enqueue

Enqueue(K2) K2

14

27/296

Esempio

K1

Dequeue Enqueue

Enqueue(K3) K2 K3

28/296

Esempio

K2

Dequeue Enqueue

K3K1Dequeue

15

29/296

Esempio

K3

Dequeue Enqueue

K2Dequeue

30/296

Vettore buffer di N+1 elementi per code di Nelementi

Variabili:head: indice del primo elemento inseritotail: indice del primo elemento disponibileper l’inserimento

Vettore come buffer circolare

Complessità delle operazioni T(n) = O(1)

Implementazione tramite vettore

16

31/296

Dequeue: incrementa head modulo N+1

Enqueue: incrementa tail modulo N+1

Inizialmente head = 0, tail = 0

Coda piena (overflow):head = (tail + 1) modulo N+1

Coda vuota (underflow):head = tail

Buffer circolare

32/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

head tail

Coda vuota

17

33/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

head tail

Enqueue(A)

34/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(A)

A

head tail

18

35/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(B)

A

tailhead

36/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(B)

A

tail

B

head

19

37/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(C)

A

tail

B

head

38/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(C)

A B

tailhead

20

39/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(D)

A B

tailhead

40/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(D)

A B

tail

D

head

21

41/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

A B

tail

D

head

42/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

B

head tail

DA

22

43/296

Esempio

C

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(E)

B

head tail

D

44/296

Esempio

C E

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(E)

B

head tail

D

23

45/296

Esempio

C E

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(F)

B

head tail

D

46/296

Esempio

C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(F)

B

head

D

tail

Coda piena

24

47/296

Esempio

C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

B

head

D

tail

48/296

Esempio

C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

head

D

tail

B

25

49/296

Esempio

C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(G)

head

D

tail

50/296

Esempio

G C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Enqueue(G)

head

D

tail Coda piena

26

51/296

Esempio

G C E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

head

D

tail

52/296

Esempio

G E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

head

D

tail

C

27

53/296

Esempio

G E F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

headtail

D

54/296

Esempio

G F

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

headtail

E

28

55/296

Esempio

G

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

head tail

F

56/296

Esempio

1 2 3 4 50

Coda con max 5 elementi (N=5)

Dequeue

G

head tailCoda vuota

29

57/296

Implementazione in C

#define DIM 10int buffer[DIM+1];int tail=0, head=0;

int enqueue(int elem);int dequeue(void);int empty(void);

58/296

Implementazione in C

int enqueue(int elem){if((tail+1)==head||(tail==DIM && head==0))return(-1);

buffer[tail++] = elem;if(tail == (DIM+1))tail = 0;

return(0);}

30

59/296

Implementazione in C

int dequeue(void){int ret;if(head == tail)

return(-1);ret = buffer[head++];if(head == (DIM+1))

head = 0;return(ret);

}

60/296

Implementazione in C

int empty(void){

if(head == tail)return(1);

elsereturn(0);

}

31

61/296

Algoritmi e Programmazione Avanzata - teoria

62/296

Struttura dati lineare:elementi allocati/deallocati separatamenteelementi concatenati (e quindi accessibili) attraverso puntatorivariabile head: accesso al primo elementooperazioni:

- insert (in testa di linea non ordinata o in lista ordinata)

- search- delete

Definizione

32

63/296

Vantaggi/svantaggi:

memoria corrispondente agli elementieffettivamente utilizzataaccesso mediante scansione

Classificazione:

liste ordinate / non ordinate

Definizione

64/296

Operazioni:Insert(L, k): nserisce una chiave k nella lista L

- liste non ordinate: in testa

- liste ordinate: posizione corretta

Search(L, k): cerca la chiave k nella lista L Delete(L, x): cancella la chiave k dalla lista L dato il puntatore x all’elemento che la contiene.

Definizione

33

65/296

Esempio

head(L)

key nextLista concatenata doppia

head(L) NIL

key nextLista concatenata semplice

NILNIL

previous

66/296

Inserimento in testa (lista non ordinata)

head(L) Z P NIL

34

67/296

Inserimento in testa (lista non ordinata)

head(L) Z P NIL

A NILxinsert(L, x)

68/296

Inserimento in testa (lista non ordinata)

head(L)

Z P NIL

A next(x) = head(L)head(L) = x

35

69/296

Implementazione C

struct e {int key;struct e *next;};

struct e *insert(struct e *pTop,int val);

struct e *search(struct e *pTop,int *val,int *status);

struct e *newE( );

70/296

Implementazione C

struct e *newE ( )

36

71/296

Implementazione C

struct e *newE ( )

Allocazione di un nuovo nodo

72/296

Implementazione C

struct e *newE ( ){

struct e *ePtr;

ePtr = (struct e *) malloc (sizeof(struct e));

if (ePtr==NULL) {fprintf (stderr, "Allocazione

fallita.");exit (FAILURE);

}return (ePtr);

}

37

73/296

Implementazione C

struct e *insert (struct e *pTop,int val)

74/296

Implementazione C

struct e *insert (struct e *pTop,int val)

Inserimento in testa

38

75/296

Implementazione C

struct e *insert (struct e *pTop,int val){

struct e *pNew;

pNew = newE ();

pNew->key = val;pNew->next = pTop;

76/296

Implementazione C

struct e *insert (struct e *pTop,int val){

struct e *pNew;

pNew = newE ();

pNew->key = val;pNew->next = pTop;

next(x) = head(L)

39

77/296

Implementazione C

struct e *insert (struct e *pTop,int val){

struct e *pNew;

pNew = newE ();

pNew->key = val;pNew->next = pTop;pTop = pNew;

78/296

Implementazione C

struct e *insert (struct e *pTop,int val){

struct e *pNew;

pNew = newE ();

pNew->key = val;pNew->next = pTop;pTop = pNew;

head(L) = x

40

79/296

Implementazione C

struct e *insert (struct e *pTop,int val){

struct e *pNew;

pNew = newE ();

pNew->key = val;pNew->next = pTop;pTop = pNew;

return (pTop);}

80/296

Ricerca

Scansione della lista a partire da head

Confronto chiave cercata / chiave corrente

Terminazione:

trovata la chiave cercata

fine lista

41

81/296

Implementazione C

struct e *search (struct e *pTop,int *val,int*status)

82/296

Implementazione C

struct e *search (struct e *pTop,int *val,int*status) ricerca

42

83/296

Implementazione C

struct e *search (struct e *pTop,int *val,int*status){

struct e *pTmp;*status = FAILURE;pTmp=pTop;while ((pTmp!=NULL) && (*status==FAILURE))

{if (pTmp->key==*val) {

*status = SUCCESS;} else {

pTmp=pTmp->next;}

}

84/296

Implementazione C

if (*status==SUCCESS) {fprintf (stdout,"Trovato %d\n",pTmp->key);

} else {fprintf (stdout,"NON Trovato \n");

}

return (pTop);}

43

85/296

Cancellazione

Richiede:

una ricerca, che produce il puntatore x all'elemento da cancellare

il riaggiustamento dei puntatori- all’elemento da cancellare- all’elemento precedente- all’elemento seguente (lista concatenata doppia)

86/296

Cancellazione

head(L) NILNIL P A Z

44

87/296

Cancellazione

head(L) NILNIL P A Z

delete(L, x) x

88/296

Cancellazione

prev[next[x]] = prev[x]next[prev[x]] = next[x]

head(L) NILNIL P A Z

45

89/296

Complessità

Inserzione in testa di lista non ordinata:T(n) = O(1)

Ricerca:T(n) = O(n)

Cancellazione (dato il puntatore all’elemento da cancellare):

T(n) = O(1)

90/296

Algoritmi e Programmazione Avanzata - teoria

46

91/296

Tipo di dato astratto con operazioni:searchminimummaximumpredecessorsuccessorinsertdelete

Implementano dizionari e code prioritarie.

Definizione 1/2

92/296

Proprietà:∀nodo x vale che:

∀ nodo y ∈Left(x), key[y] ≤ key[x]∀ nodo y ∈Right(x), key[y] ≥ key[x]

Definizione 2/2

≤ ≥Left(x) Right(x)

x

47

93/296

Esempi

5

3 7

2 4 8

5

3

7

2

4

8

94/296

Attraversamenti

Attraversamento: elenco dei nodi secondo una strategia:

Pre-ordine: x, Left(x), Right(x)In-ordine: Left(x), x, Right(x) Post-ordine: Left(x), Right(x), x

Complessità: T(n) = Θ(n)

Attraversamento in-ordine: ordinamento crescente delle chiavi.

48

95/296

Esempio

15

6 18

17 203 7

2 4 13

9

96/296

Esempio

15

6 18

17 203 7

2 4 13

9

15Visita in pre-ordine

1

49

97/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

2

1

Visita in pre-ordine

6

98/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

3

2

1

Visita in pre-ordine

63

50

99/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

2

1

Visita in pre-ordine

632

100/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

1

Visita in pre-ordine

6324

51

101/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

1

Visita in pre-ordine

63247

102/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

7

1

Visita in pre-ordine

6324713

52

103/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

8

7

1

Visita in pre-ordine

63247139

104/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

8

7

1

9

Visita in pre-ordine

6324713918

53

105/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

8

7

1

10

9

Visita in pre-ordine

632471391817

106/296

Esempio

15

6 18

17 203 7

2 4 13

9

15

4

3

5

2

6

8

7

1

10

9

11

Visita in pre-ordine

63247139181720

54

107/296

Esempio

15

6 18

17 203 7

2 4 13

9

Visita in-ordine

108/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

Visita in-ordine

55

109/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

Visita in-ordine

3

110/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

Visita in-ordine

34

56

111/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

Visita in-ordine

346

112/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

Visita in-ordine

3467

57

113/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

Visita in-ordine

34679

114/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

7

Visita in-ordine

3467913

58

115/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

7

8

Visita in-ordine

346791315

116/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

7

8

9

Visita in-ordine

34679131517

59

117/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

7

8

10

9

Visita in-ordine

3467913151718

118/296

Esempio

15

6 18

17 203 7

2 4 13

9

2

1

2

3

4

5

6

7

8

10

9 11

Visita in-ordine

346791315171820

60

119/296

Esempio

15

6 18

17 203 7

2 4 13

9

Visita in post-ordine

120/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

Visita in post-ordine2

61

121/296

Esempio

15

6 18

17 203 7

2 4 13

9

1 2

Visita in post-ordine24

122/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

Visita in post-ordine243

62

123/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

4

Visita in post-ordine2439

124/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

4

5

Visita in post-ordine243913

63

125/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

6

4

5

Visita in post-ordine2439137

126/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

7

6

4

5

Visita in post-ordine24391376

64

127/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

7

6

4

5

8

Visita in post-ordine2439137617

128/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

7

6

4

5

98

Visita in post-ordine243913761720

65

129/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

7

6

4

5

9

10

8

Visita in post-ordine24391376172018

130/296

Esempio

15

6 18

17 203 7

2 4 13

9

1

3

2

7

6

4

5

9

10

8

11

Visita in post-ordine2439137617201815

66

131/296

Search

Ricerca ricorsiva di un nodo con chiave k:

percorrimento dell’albero dalla radice;

terminazione: trovato k oppure giunti a una foglia;

ricorsione: dal nodo x - su sottoalbero sinistro se k < key[x] - su sottoalbero destro se k ≥ key[x].

132/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

67

133/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

134/296

Esempio

15

18

17 20

k = 1313 ≠ 15

6

3 7

2 4 13

9

68

135/296

Esempio

15

18

17 20

k = 1313 ≠ 1513 < 15

6

3 7

2 4 13

9

136/296

Esempio

15

18

17 20

k = 1313 ≠ 1513 < 15

6

3 7

2 4 13

9

69

137/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

138/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

70

139/296

Esempio

15

18

17 20

k = 1313 ≠ 6

6

3 7

2 4 13

9

140/296

Esempio

15

18

17 20

k = 1313 ≠ 613 > 6

6

3 7

2 4 13

9

71

141/296

Esempio

15

18

17 20

k = 1313 ≠ 613 > 6

6

3 7

2 4 13

9

142/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

72

143/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

144/296

Esempio

15

18

17 20

k = 1313 ≠ 7

6

3 7

2 4 13

9

73

145/296

Esempio

15

18

17 20

k = 1313 ≠ 713 > 7

6

3 7

2 4 13

9

146/296

Esempio

15

18

17 20

k = 1313 ≠ 713 > 7

6

3 7

2 4 13

9

74

147/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

148/296

Esempio

15

18

17 20

k = 13

6

3 7

2 4 13

9

75

149/296

Esempio

15

18

17 20

k = 1313=13

6

3 7

2 4 13

9

150/296

Esempio

15

18

17 20

k = 1313=13

6

3 7

2 4 13

9 Trovato!

76

151/296

Min e max

Min:seguire il puntatore al sottoalbero sinistro finchè esiste.

Max:seguire il puntatore al sottoalbero destro finchèesiste.

152/296

Esempio

15

6 18

17 203 7

2 4 13

9

77

153/296

Esempio

15

6 18

17 203 7

2 4 13

9

154/296

Esempio

15

6 18

17 203 7

2 4 13

9

78

155/296

Esempio

15

6 18

17 203 7

2 4 13

9

min = 2

156/296

Esempio

15

6 18

17 203 7

2 4 13

9

min = 2

79

157/296

Esempio

15

6 18

17 203 7

2 4 13

9

min = 2max = 20

158/296

Successor

Successore di un nodo x:nodo con la più piccola chiave k > key[x].Due casi:

∃ Right(x): succ(x) = min(Right(x))∃ Right(x): succ(x) = primo antenato di x ilcui figlio sinistro è anche un antenato di x.

x

p[x]

x

p[x]

80

159/296

Esempio

15

6 18

17 203 7

2 4 13

9

160/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

81

161/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

162/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

82

163/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

succ(x)

164/296

Esempio

15

6 18

17 203 7

2 4 13

9

83

165/296

Esempio

15

6 18

17 203 7

2 4 13

9x

166/296

Esempio

15

6 18

17 203 7

2 4 13

9x

84

167/296

Esempio

15

6 18

17 203 7

2 4 13

9x

succ(x)

168/296

Predecessor

Predecessore di un nodo x:nodo con la più grande chiave k < key[x].

Due casi:

∃ Left(x): pred(x) = max(Left(x))

∃ Left(x): pred(x) = primo antenato di x il cui figlio destro è anche un antenato di x.

85

169/296

Esempio

15

6 18

17 203 7

2 4 13

9

170/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

86

171/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

172/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

87

173/296

Esempio

15

6 18

17 203 7

2 4 13

9

x

pred(x)

174/296

Esempio

15

6 18

17 203 7

2 4 13

9

88

175/296

Esempio

15

6 18

17 203 7

2 4 13

9 x

176/296

Esempio

15

6 18

17 203 7

2 4 13

9 x

89

177/296

Esempio

15

6 18

17 203 7

2 4 13

9 x

pred(x)

178/296

Insert

Inserire in un albero binario di ricerca un nodo z con chiave key[z] ⇒ mantenimento della proprietà:

creazione del nuovo nodo z, con Left[z]=Right[z]=NIL;

posizione di inserimento di z come foglia, simulando la ricerca di key[z];

aggiornamento dei puntatori.

90

179/296

Esempio

insert(T,z)

z12

5 18

15 202 9

17

13

T

180/296

Esempio

insert(T,z)

z12

5 18

15 202 9

17

13

T

91

181/296

Esempio

insert(T,z)

z12

5 18

15 202 9

17

13

T

182/296

Esempio

z12

5 18

15 202 9

17

13

T insert(T,z)

92

183/296

Esempio

z12

5 18

15 202 9

17

13

T insert(T,z)

184/296

Esempio

z12

5 18

15 202 9

17

13

T insert(T,z)

93

185/296

Esempio

12

5 18

15 202 9

1713

T

186/296

Delete

Cancellazione da un albero binario di ricerca di un nodo z ⇒

mantenimento della proprietàmantenimento della struttura ad alberobinario.

Tre casi:1. nodo z foglia2. nodo z con 1 solo figlio 3. nodo z con 2 figli.

94

187/296

Caso 1: foglia

15

6 18

17 203 7

2 4 13

9 z

188/296

Caso 1: foglia

15

6 18

17 203 7

2 4 13

9 z

delete(z):rimozione immediata.

95

189/296

Caso 1: foglia

15

6 18

17 203 7

2 4 13

190/296

Caso 2: 1 figlio

15

6 18

17 203 7

2 4 13

9

delete(z):

z

96

191/296

Caso 2: 1 figlio

15

6 18

17 203 7

2 4 13

9

delete(z):

x

z

192/296

Caso 2: 1 figlio

15

6 18

17 203 7

2 4 13

9

x

p

delete(z):il figlio x di z diventafiglio del padre p di z.

z

97

193/296

Caso 2: 1 figlio

15

6 18

17 203

2 4 13

9

194/296

Caso 3: 2 figli

15

6 18

17 203 7

2 4 13

9

delete(z):z

98

195/296

Caso 3: 2 figli

15

6 18

17 203 7

2 4 13

9

y

delete(z):si cancella y = succ(z)z

196/296

Caso 3: 2 figli

15

6 18

17 203 7

2 4 13

9

y

delete(z):si cancella y = succ(z)si copia y su z

z

99

197/296

Caso 3: 2 figli

15

6 18

17 203 7

2 4 13

9

y

delete(z):si cancella y = succ(z)si copia y su z

z

Nota: y può esserepred(z)

198/296

Caso 3: 2 figli

17

6 18

203 7

2 4 13

9

100

199/296

Complessità

Le operazioni hanno complessità T(n) = O(h):

albero con n nodi completamente bilanciato- altezza h = log2 n

albero con n nodi completamente sbilanciato- altezza h = n

O(log2 n) ≤ T(n) ≤ O(n)

200/296

101

201/296

Tipo di dato astrattoModello: insieme finito di simboli. Operazioni:

searchinsertdelete.

? ∃ corrispondenza biunivoca insieme finito di simboli

e intervallo di interi.

Dizionario

202/296

Applicazioni

Tabella dei simboli di un compilatore

Chiave = nome di un identificatoreDati aggiuntivi = tipo, contesto, dichiarazione.

Cache di file o URL

Chiave = pathDati aggiuntivi = attributi e contenuto.

102

203/296

Chiave k ∈ U = {0, 1, …, m-1}

Tutte le chiavi sono distinte.

Vettore T[0, 1, …, m-1]:se ∃ k, T[k] punta a k, altrimenti T[k] = NIL.

Memorizzazione di un insieme K di |K| chiavi.

Tabelle ad accesso diretto 1/2

204/296

Tabelle ad accesso diretto 2/2

U (universo delle chiavi)

K (chiavi usate)

•7•4 •9

•5•3•8

•6

•0

•1

•2

012345678

m-1

23

5

8

chiave k

dati associati

T

x

103

205/296

Operazioni

Search(T, k)

return(T[k])

Insert(T, x)

T[key[x]] = x

Delete(T, x)

T[key[x]] = NIL

206/296

Vantaggi/svantaggi

Complessità delle operazioni: T(n) = O(1)

Occupazione di memoria S(n) = O(|U|) = O(m)

applicabile per m piccolospreco di memoria per |K| << m.

104

207/296

Tabelle di hash

In generale:m grande (vettore T non allocabile)|K| << m.

Tabella di hash:tipo di dato astratto con occupazione di spazio O(|K|) e tempo medio di accesso O(1).

208/296

Funzione di hash 1/2

La tabella di hash contiene |K| elementi (|K|<<|U|)

Funzione di hash h: mappa una chiave k in una posizione del vettore h(k)

h: U → { 0, 1, ..., m-1 }

Elemento x viene memorizzato nella locazione T[h(key[x])]

105

209/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

210/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

h(k1)

106

211/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

h(k1)

h(k2)

212/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

h(k1)

h(k2)

h(k3)

107

213/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

h(k1)h(k4)

h(k2)

h(k3)

214/296

Funzione di hash 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

h(k1)h(k4)

h(k5)=h(k2)

h(k3)

Collisione

108

215/296

Progetto della funzione di hash 1/2

Funzione ideale

hashing uniforme semplice:se le chiavi k sono equiprobabili, allora i valori di h(k) devono essere equiprobabili.

∑=

−==jkhk

mjm

kP)(:

1,,1,0,1

)( K

216/296

Progetto della funzione di hash 2/2

In pratica:

k non sono equiprobabili, anzi correlate:- usare tutti i bit della chiave- “amplificare” le differenze.

chiavi come numeri interi (illimitati)- “abc” diventa ‘a’*2562 + ‘b’*256 + ‘c’.

109

217/296

Metodi

Divisione:

h(k) = k mod m

m: primo non troppo vicino a potenza di 2.

Evitare che m sia:- potenza di 2 (usa solo gli ultimi m bit di k);- una potenza di 10 (se i k sono numeri

decimali);- 2p-1 (per stringhe di caratteri in base 2p,

trasposizioni di caratteri ⇒ collisioni).

218/296

Esempio 1/2

n = 2000 elementi previsti

numero di confronti medio pari a 3 nelle ricerche

m = 701: numero primo vicino a 2000/3 ma distante dalle potenze di 2

h(k) = k mod 701

110

219/296

Esempio 2/2

Moltiplicazione:data costante 0<A<1h(k) = m ⋅ (k⋅A - k⋅A)k⋅A “rimescola” i bit i km ⋅ (k⋅A - k⋅A) espande l’intervallo [0,1]nell’intervallo [0,m].

Scelta:m potenza di 2 (estrazione di sotto-sequenzadi bit);A = (√5 – 1) / 2 = 0.6180339887.

220/296

Collisione

Definizione: collisione: h(ki)=h(kj) per ki ≠ kj

Le collisioni sono inevitabili, occorre:minimizzarne il numero (buona funzione dihash);gestirle:- linear chaining- open addressing.

111

221/296

Linear Chaining 1/2

Più elementi possono risiedere nella stessa locazione della tabella T ⇒ lista concatenata.

Operazioni:inserimento in testa alla listaricerca nella listacancellazione dalla lista.

222/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

•k6

112

223/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k1

•k6

224/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k1

k2

•k6

113

225/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k1

k3

k2

•k6

226/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k1

k4

k3

k2

•k6

114

227/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k1

k4

k3

k5 k2

•k6

228/296

Linear Chaining 2/2

•k1

012345678

m-1

T

U

•k3

•k2

•k4

•k5

k6

k4

k3

k5 k2

•k6

k1

115

229/296

Complessità 1/2

Ipotesi:Liste non ordinate:

n = numero di elementi memorizzatim = dimensione della tabella di hash.

Hashing semplice uniforme: h(k) ha egual probabilità di generare gli m valori di uscita.

Definizionefattore di carico α=n/m (>, = o < 1)

230/296

Complessità 2/2

Inserimento: T(n) = O(1)

Ricerca: caso peggiore T(n) = Θ(n)caso medio T(n) = O(1+α)

Cancellazione:T(n) = O(1) se disponibile il puntatore ad xe la lista è doppiamente linkata;come la ricerca se disponibile il valore di x,oppure il valore della chiave k, oppure lalista è semplicemente linkata.

116

231/296

Ogni cella di T può contenere un soloelemento.

Tutti gli elementi sono memorizzati in T.

Collisione: ricerca di cella non ancora occupata mediante probing:

generazione di una permutazione dellecelle = ordine di ricerca della cella libera.

h(k, i) : U × { 0,1,...,m-1 } → { 0,1,...,m-1 }

Open addressing

α≤1

chiave tentativo (0…m-1)

232/296

Funzioni di probing

Linear probingh(k, i) = (h’(k)+i) mod m

Double hashingh(k, i) = (h1(k)+ i h2(k) ) mod m dove:

h1(k) = k mod mh2(k) = 1 + (k mod m’) m’= m-1 o m-2

Quadratic probingh(k, i) = (h’(k)+ c1i + c2i2) mod m c1 e c2 ≠ 0

117

233/296

Operazioni 1/2

Insert:tentativo i=0calcola h(k, i)se libero, inserisci chiave, altrimenti incrementa iripeti fino a i=m

Search:tentativo i=0calcola h(k, i)se trovata chiave, termina con successoincrementa iripeti fino a i=m o cella vuota (insuccesso).

234/296

Operazioni 2/2

Delete:operazione complessa che interrompe le catene di collisione.

L’open addressing è in pratica utilizzato solo quando non si deve mai cancellare.

118

235/296

Complessità

Ipotesi:hashing semplice uniformeprobing uniforme.

Tentativi di “probing”:per l’inserimento: 1/(1–α)per la ricerca:

- senza successo: 1/(1–α)- con successo: 1/α ln (1/(1- α)) + 1/ α

236/296

Esempio 1

Inserimento delle chiavi

10, 22, 31, 4, 15, 28, 17, 88, 59

in tabella con m=11 con open addressing.

119

237/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

238/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

0123456789

10

120

239/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

10

0123456789

10

240/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

10

0123456789

10

121

241/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

0123456789

10

242/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

4

0123456789

10

122

243/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

4

0123456789

10

Collisione:h(15, 0) = 4

244/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

154

0123456789

10

Collisione:h(15, 1) = 5

123

245/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

28154

0123456789

10

246/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

28154

0123456789

10

Collisione:h(17, 0) = 6

124

247/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

0123456789

10

Collisione:h(17, 1) = 7

248/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

0123456789

10

Collisione:h(88, 0) = 0

125

249/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

880123456789

10

Collisione:h(88, 1) = 1

250/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

880123456789

10

Collisione:h(59, 0) = 4

126

251/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

880123456789

10

Collisione:h(59, 1) = 5

252/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

880123456789

10

Collisione:h(59, 2) = 6

127

253/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031

1728154

880123456789

10

Collisione:h(59, 3) = 7

254/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031591728154

880123456789

10

Collisione:h(59, 4) = 8

128

255/296

Esempio 1

10, 22, 31, 4, 15, 28, 17, 88, 59

Linear probingh(k, i) = (k mod 11 + i) mod 11

22

1031591728154

88

primaryclustering

0123456789

10

256/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

129

257/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

10

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

258/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

10

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

130

259/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

260/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

131

261/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Collisione:h(15, 0) = 4

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

262/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

4

0123456789

10

Collisione:h(15, 1) = 8

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

132

263/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

264/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(17, 0) = 6

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

133

265/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(17, 1) = 10

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

266/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(17, 2) = 9

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

134

267/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(17, 3) = 3

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

268/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 0) = 0

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

135

269/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 1) = 4

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

270/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 2) = 3

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

136

271/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 3) = 8

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

272/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 4) = 8

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

137

273/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 5) = 3

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

274/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 6) = 4

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

138

275/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 7) = 0

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

17

276/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(88, 8) = 2

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

1788

139

277/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(59, 0) = 4

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

8817

278/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

103115

28

4

0123456789

10

Collisione:h(59, 1) = 8

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

8817

140

279/296

Esempio 2

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031155928

4

0123456789

10

Collisione:h(59, 2) = 7

Quadratic probingh(k, i) = (k mod 11+i+3i2) mod 11

8817

280/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

141

281/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

10

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

282/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

10

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

142

283/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

284/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

143

285/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Collisione:h(15, 0) = 4

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

286/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Collisione:h(15, 1) = 10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

144

287/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

4

0123456789

10

Collisione:h(15, 2) = 5

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

15

288/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

28

4

0123456789

10

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

15

145

289/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

28

4

0123456789

10

Collisione:h(17, 0) = 6

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

15

290/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

28

4

0123456789

10

Collisione:h(17, 1) = 3

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

146

291/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

28

4

0123456789

10

Collisione:h(88, 0) = 0

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

292/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

28

4

0123456789

10

Collisione:h(88, 1) = 9

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

147

293/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

8828

4

0123456789

10

Collisione:h(88, 2) = 7

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

294/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

8828

4

0123456789

10

Collisione:h(59, 0) = 4

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

148

295/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

8828

4

0123456789

10

Collisione:h(59, 1) = 3

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15

296/296

Esempio 3

10, 22, 31, 4, 15, 28, 17, 88, 59

22

1031

8828

4

59

0123456789

10

Collisione:h(59, 2) = 2

Double hashingh(k, i) = (k mod 11+i(1+k mod 10)) mod 11

17

15